2018–2026
1,438 posts
2026 187
October 2026
- 7 Ways Your AI Agent Is Wasting Tokens (And What to Do Instead)
- Fine-Tuning vs. Frozen Embeddings: When to Adapt the LLM vs. the Sklearn Head
- Context Managers Beyond Opening Files in Python
- Robust Serialization with JSON and Custom Types
- Speculative Decoding Explained: How to Get 3× Faster Inference from Any LLM
- How to Build a Multi-Modal RAG Pipeline for Images and Documents in Python
- pgvector vs. Dedicated Vector Databases: A Production Benchmark
- Descriptors and Controlled Attributes in Python
- Iterators and Generators for Memory-Efficient Processing
- Choosing a Chunking Strategy for Your LLM Apps: A Decision-Tree Approach
- Building a Custom LLM Evaluation Harness in Python from Scratch
- Building a RAG Pipeline with LLM Embeddings and Scikit-learn
- AI Agent Benchmarks Explained: SWE-Bench, GAIA, WebArena, and More
- How to Fine-Tune Llama 3 for Custom Tool Calling with Unsloth in Python
- Evaluating Graph-RAG vs. Standard RAG: A Hallucination Benchmark on Fact-Dense Queries
- Choosing the Right Agentic AI Framework for 2026: A Decision-Tree Approach
- Synchronous vs. Asynchronous Agent Execution: Architecture Patterns for Production
- How (and Why) to Build an AI Agent from Scratch in Python
- Adding Temporal Reasoning to Graph-RAG: Tracking Fact Freshness and Staleness
- AI Agent Observability: Logging, Tracing, and Debugging Explained
September 2026
- Automating Knowledge Graph Population: Extracting Entities and Triples from Unstructured Text with an LLM
- Local Agentic AI Workflows with Hermes + Ollama
- Tool Calling vs. Code Execution for AI Agents: Choosing the Right Action Primitive
- Agent or Workflow? A Practical Test for Knowing When You Actually Need an AI Agent
- RAG vs. Fine-Tuning for Domain Adaptation: When to Use Which
- Monitoring Embedding Drift in Production Scikit-LLM Pipelines
- The Roadmap to Mastering LLM Inference Optimization
- Build And Understand a Vector Database From Scratch in 10 Easy Steps
- What’s Actually Inside 24,723 Tokens of a Search Result? We Broke It Down, Field by Field
- Multilingual Text Classification with Scikit-LLM and Multilingual Embeddings
- The Roadmap to Mastering Voice Agents
- Treating Prompt Templates as Hyperparameters in Scikit-LLM GridSearchCV
- A Gentle Introduction to Model Distillation
- Fine-Tuning Agentic AI: A Practical Guide
- How to Combine Traditional Machine Learning with Agentic Reasoning
- Versioning and Tracking Scikit-LLM Experiments
- Chain of Thought vs. Tree of Thoughts: Which is Best for AI Agents?
- Dataclasses for Structured Application Data
- Single-Agent vs. Multi-Agent Systems: When the Complexity Is Worth It
- AI Agent Memory Design: What Works and What Doesn’t
- 3 Ways to Enhance Your AI Model’s Interpretability
August 2026
- Combining LLM Embeddings with Tabular Features in a Unified Scikit-learn Pipeline
- Interpretable Text Classification: Probing Scikit-LLM Embedding Spaces
- Learn Vectorized Thinking in Python Through Examples
- Comparing Local Tool Calling: Gemma 4 vs. Llama 3 vs. Mistral
- Integrating Agentic AI with Existing Machine Learning Pipelines
- How to Build a Robust RAG System with Minimal Resources
- Managing Small Context Windows in Language Models
- 7 Regression Tests Every AI Agent Should Pass Before Deploy
- Understanding the Role of Latent Space in Machine Learning Models
- Retrieval vs. Memory in Agentic AI Systems
- 7 Async Patterns for Running Agents Concurrently in Python
- Prompt Caching vs. Fine-Tuning: A Cost and Latency Decision Framework
- Identifying Token Costs Hiding in Your Agentic Loop
- Designing AI Agents That Can Self-Correct
- 7 Chunking Strategies That Decide Whether Your RAG Works
- Measuring Performance of Transformer Inference
- Static vs. Dynamic vs. Continuous Batching in LLM Inference
- Decoding Strategies and Output Control
July 2026
- Using a Transformer Model: From Training to Inference
- The End-to-End Agentic AI Pipeline
- Ollama vs. LM Studio vs. llama.cpp: Which Local AI Runtime Should You Use in 2026?
- 5 Architectural Patterns for Persistent Memory and State in AI Agents
- Stateful vs. Stateless Agent Design: Tradeoffs for Scalable Agentic Systems
- An Introduction to Loop Engineering
- The Current State of Agentic AI
- Building Agentic Workflows in Python with LangGraph
- Agentic AI Security: Defending Against Prompt Injection and Tool Misuse
- Run a Local AI Model with Ollama in 15 Minutes
- Scikit-Ollama for Scikit-LLM/Ollama Integration
- LLM Evaluation Frameworks Compared: How to Actually Measure What Your Model Does
- Building AI Agents? Here Are Some Anti-Patterns to Avoid.
- Choosing the Right AI Agent Memory Strategy: A Decision-Tree Approach
- LLM Orchestration Frameworks Compared: LangChain vs. LlamaIndex vs. Raw API Calls
- Tools vs. Subagents: Building Effective AI Agents Without Over-Engineering
- The Complete Guide to Tool Selection in AI Agents
- Context vs. Memory Engineering in Agentic AI Systems
June 2026
- Context Window Management for Long-Running Agents: Strategies and Tradeoffs
- Model Context Protocol Explained in 3 Levels of Difficulty
- The AI Agent Tech Stack Explained
- Agentic Workflow vs. Autonomous Agent: What’s the Difference?
- Context Windows Are Not Memory: What AI Agent Developers Need to Understand
- Clustering Unstructured Text with LLM Embeddings and HDBSCAN
- Building Browser-Using AI Agents in Python
- The Roadmap to Mastering AI Agent Evaluation
- Building an End-to-End Sentiment Analysis Pipeline with Scikit-LLM
- AI Agent Tool Design: What Works and What Doesn’t
- Python Concepts Every AI Engineer Must Master
- Multi-Label Text Classification with Scikit-LLM
- Multimodal Browser AI with Transformers.js for Images and Speech
- The Practitioner’s Guide to AgentOps
- Building Semantic Search with Transformers.js and Sentence Embeddings
- Using Scikit-LLM with Open-Source LLMs
- Scikit-LLM vs. Traditional Text Classifiers: When Should You Use an LLM?
- The Roadmap for Mastering LLMOps in 2026
May 2026
- Serving Multiple Users at Once: How Continuous Batching Keeps LLM Inference Efficient
- Building a Context Pruning Pipeline for Long-Running Agents
- The Statistics of Token Selection: Logits, Temperature, and Top-P Walkthrough
- Building a Multi-Tool Gemma 4 Agent with Error Recovery
- Implementing Hybrid Semantic-Lexical Search in RAG
- Building Context-Aware Search in Python with LLM Embeddings + Metadata
- How to Build a Multi-Agent Research Assistant in Python
- Agentic Programming: A Roadmap
- Prompt Engineering for Agentic AI
- Building Vector Similarity Search in PostgreSQL with pgvector
- Choosing the Right Agentic Design Pattern: A Decision-Tree Approach
- LLM Observability Tools for Reliable AI Applications
- Implementing Prompt Compression to Reduce Agentic Loop Costs
- Implementing Permission-Gated Tool Calling in Python Agents
- The Roadmap to Mastering Tool Calling in AI Agents
- Implementing Statistical Guardrails for Non-Deterministic Agents
- Agentic RAG Explained in 3 Levels of Difficulty
April 2026
- Effective KV Compression with TurboQuant
- Building AI Agents in Python with Pydantic AI
- Effective Context Engineering for AI Agents: A Developer’s Guide
- Text Summarization with Scikit-LLM
- Building AI Agents with Local Small Language Models
- Train, Serve, and Deploy a Scikit-learn Model with FastAPI
- AI Agent Memory Explained in 3 Levels of Difficulty
- Getting Started with Zero-Shot Text Classification
- The Complete Guide to Inference Caching in LLMs
- Python Decorators for Production Machine Learning Engineering
- 5 Techniques for Efficient Long-Context RAG
- How to Implement Tool Calling with Gemma 4 and Python
- Structured Outputs vs. Function Calling: Which Should Your Agent Use?
- Beyond Vector Search: Building a Deterministic 3-Tiered Graph-RAG System
- The Roadmap to Mastering Agentic AI Design Patterns
- A Hands-On Guide to Testing Agents with RAGAs and G-Eval
- Handling Race Conditions in Multi-Agent Orchestration
- Top 5 Reranking Models to Improve RAG Results
- 7 Machine Learning Trends to Watch in 2026
March 2026
- Building a ‘Human-in-the-Loop’ Approval Gate for Autonomous Agents
- From Prompt to Prediction: Understanding Prefill, Decode, and the KV Cache in LLMs
- 7 Essential Python Itertools for Feature Engineering
- LlamaAgents Builder: From Prompt to Deployed AI Agent in Minutes
- Vector Databases Explained in 3 Levels of Difficulty
- 5 Practical Techniques to Detect and Mitigate LLM Hallucinations Beyond Prompt Engineering
- Beyond the Vector Store: Building the Full Data Layer for AI Applications
- 7 Steps to Mastering Memory in Agentic AI Systems
- Why Agents Fail: The Role of Seed Values and Temperature in Agentic Loops
- 5 Production Scaling Challenges for Agentic AI in 2026
- 7 Readability Features for Your Next Machine Learning Model
- Everything You Need to Know About Recursive Language Models
- Building Smart Machine Learning in Low-Resource Settings
- Setting Up a Google Colab AI-Assisted Coding Environment That Actually Works
- From Text to Tables: Feature Engineering with LLMs for Tabular Data
- The 6 Best AI Agent Memory Frameworks You Should Try in 2026
- Vector Databases vs. Graph RAG for Agent Memory: When to Use Which
- 5 Essential Security Patterns for Robust Agentic AI
- Deploying AI Agents to Production: Architecture, Infrastructure, and Implementation Roadmap
- Build Semantic Search with LLM Embeddings
February 2026
- Can LLM Embeddings Improve Time Series Forecasting? A Practical Feature Engineering Approach
- KV Caching in LLMs: A Guide for Developers
- How to Combine LLM Embeddings + TF-IDF + Metadata in One Scikit-learn Pipeline
- Introduction to Small Language Models: The Complete Guide for 2026
- Beyond Accuracy: 5 Metrics That Actually Matter for AI Agents
- Building a Simple MCP Server in Python
- Agentify Your App with GitHub Copilot’s Agentic Coding SDK
- LLM Embeddings vs TF-IDF vs Bag-of-Words: Which Works Better in Scikit-learn?
- Top 7 Small Language Models You Can Run on a Laptop
- Choosing Between PCA and t-SNE for Visualization
- The Machine Learning Practitioner’s Guide to Speculative Decoding
- Document Clustering with LLM Embeddings in Scikit-learn
- The 7 Biggest Misconceptions About AI Agents (and Why They Matter)
- Agent Evaluation: How to Test and Measure Agentic AI Performance
- Export Your ML Model in ONNX Format
- 7 Advanced Feature Engineering Tricks Using LLM Embeddings
- A Beginner’s Reading List for Large Language Models for 2026
January 2026
- 7 Important Considerations Before Deploying Agentic AI in Production
- 5 Ways to Use Cross-Validation to Improve Time Series Models
- The 3 Invisible Risks Every LLM App Faces (And How to Guard Against Them)
- Leveling Up Your Machine Learning: What To Do After Andrew Ng’s Course
- The 2026 Time Series Toolkit: 5 Foundation Models for Autonomous Forecasting
- Everything You Need to Know About How Python Manages Memory
- The Machine Learning Practitioner’s Guide to Model Deployment with FastAPI
- Top 5 Agentic AI Website Builders (That Actually Ship)
- The Complete Guide to Data Augmentation for Machine Learning
- The Beginner’s Guide to Computer Vision with Python
- Uncertainty in Machine Learning: Probability & Noise
- How to Read a Machine Learning Research Paper in 2026
- 10 Ways to Use Embeddings for Tabular ML Tasks
- Quantizing LLMs Step-by-Step: Converting FP16 Models to GGUF
- Supervised Learning: The Foundation of Predictive Modeling
- A Gentle Introduction to Language Model Fine-tuning
- Mastering LLM Tool Calling: The Complete Framework for Connecting Models to the Real World
- 7 Agentic AI Trends to Watch in 2026
- Gradient Descent:The Engine of Machine Learning Optimization
2025 280
December 2025
- Train Your Large Model on Multiple GPUs with Tensor Parallelism
- Train Your Large Model on Multiple GPUs with Fully Sharded Data Parallelism
- Beyond Short-term Memory: The 3 Types of Long-term Memory AI Agents Need
- Train Your Large Model on Multiple GPUs with Pipeline Parallelism
- 5 Python Libraries for Advanced Time Series Forecasting
- Training a Model on Multiple GPUs with Data Parallelism
- Train a Model Faster with torch.compile and Gradient Accumulation
- Training a Model with Limited Memory using Mixed Precision and Gradient Checkpointing
- Practical Agentic Coding with Google Jules
- Evaluating Perplexity on Language Models
- 3 Smart Ways to Encode Categorical Features for Machine Learning
- Pretraining a Llama Model on Your Local GPU
- Rotary Position Embeddings for Long Context Length
- How to Fine-Tune a Local Mistral or Llama 3 Model on Your Own Dataset
- 5 Agentic Coding Tips & Tricks
- The Real Cost of Inaction: How Silos Hurt Productivity for Data Scientists (Sponsored)
- Top 5 Vector Databases for High-Performance LLM Applications
- The Machine Learning Engineer’s Checklist: Best Practices for Reliable Models
- Transformer vs LSTM for Time Series: Which Works Better?
- How LLMs Choose Their Words: A Practical Walk-Through of Logits, Softmax and Sampling
- 3 Feature Engineering Techniques for Unstructured Text Data
- 3 Subtle Ways Data Leakage Can Ruin Your Models (and How to Prevent It)
- How AI Cuts Costs and Adds Value for Data Science Workflows (Sponsored)
- Creating a Llama or GPT Model for Next-Token Prediction
- Top 5 Agentic AI LLM Models
- Training a Tokenizer for the Llama Model
- Prompt Engineering for Time Series Analysis
- The Complete Guide to Using Pydantic for Validating LLM Outputs
- The Roadmap for Mastering Agentic AI in 2026
- Prompt Compression for LLM Generation Optimization and Cost Reduction
November 2025
- How to Speed Up Training Convergence of Language Models
- Fine-Tuning a BERT Model
- The Journey of a Token: What Really Happens Inside a Transformer
- Pretrain a BERT Model from Scratch
- K-Means Cluster Evaluation with Silhouette Analysis
- The Complete Guide to Docker for Machine Learning Engineers
- Preparing Data for BERT Training
- BERT Models and Its Variants
- From Shannon to Modern AI: A Complete Information Theory Guide for Machine Learning
- Why Decision Trees Fail (and How to Fix Them)
- Training a Tokenizer for BERT Models
- Forecasting the Future with Tree-Based Models for Time Series
- The Complete AI Agent Decision Framework
- Mastering JSON Prompting for LLMs
- 5 Essential Python Scripts for Intermediate Machine Learning Practitioners
- Datasets for Training a Language Model
- Building ReAct Agents with LangGraph: A Beginner’s Guide
- Expert-Level Feature Engineering: Advanced Techniques for High-Stakes Models
- Everything You Need to Know About LLM Evaluation Metrics
- The 7 Statistical Concepts You Need to Succeed as a Machine Learning Engineer
- Free AI and Data Courses with 365 Data Science—100% Unlimited Access until Nov 21
- Essential Chunking Techniques for Building Better LLM Applications
- How to Diagnose Why Your Language Model Fails
- 10 Python One-Liners for Calculating Model Feature Importance
- 7 Prompt Engineering Tricks to Mitigate Hallucinations in LLMs
October 2025
- 7 Machine Learning Projects to Land Your Dream Job in 2026
- 7 Advanced Feature Engineering Tricks for Text Data Using LLM Embeddings
- The Complete Guide to Model Context Protocol
- 10 Python One-Liners for Generating Time Series Features
- The Complete Guide to Pydantic for Python Developers
- The Machine Learning Practitioner’s Guide to Fine-Tuning Language Models
- 5 Advanced Feature Engineering Techniques with LLMs for Tabular Data
- 7 Must-Know Agentic AI Design Patterns
- Future-Proofing Your AI Engineering Career in 2026
- Revolutionizing MLOps: Enhanced BigQuery ML UI for Seamless Model Creation and Management
- The Complete Guide to Vector Databases for Machine Learning
- 3 Ways to Speed Up Model Training Without More GPUs
- 7 Feature Engineering Tricks for Text Data
- 10 Python One-Liners for Calling LLMs from Your Code
- 7 Pandas Tricks to Handle Large Datasets
- Building Transformer Models from Scratch with PyTorch (10-day Mini-Course)
- The Machine Learning Practitioner’s Guide to Agentic AI Systems
- Build an Inference Cache to Save Costs in High-Traffic LLM Apps
- 7 NumPy Tricks to Vectorize Your Code
- Is ChatGPT-5 Able to Provide Proofs for Advanced Mathematics?
- A Decision Matrix for Time Series Forecasting Models
- Algorithm Showdown: Logistic Regression vs. Random Forest vs. XGBoost on Imbalanced Data
- MinMax vs Standard vs Robust Scaler: Which One Wins for Skewed Data?
September 2025
- The Model Selection Showdown: 6 Considerations for Choosing the Best Model
- 7 Python Decorator Tricks to Write Cleaner Code
- Why and When to Use Sentence Embeddings Over Word Embeddings
- 5 AI Agent Projects for Beginners
- Beyond Vector Search: 5 Next-Gen RAG Retrieval Strategies
- Bagging vs Boosting vs Stacking: Which Ensemble Method Wins in 2025?
- 10 Machine Learning Newsletters to Stay Informed
- A Hands-On Introduction to cuML for GPU-Accelerated Machine Learning Workflows
- A Hands-On Introduction to cuDF for GPU-Accelerated Data Workflows
- Feature Scaling in Practice: What Works and What Doesn’t
- 7 NumPy Tricks for Faster Numerical Computations
- 5 Lesser-Known Visualization Libraries for Impactful Machine Learning Storytelling
- The Roadmap for Mastering AI-Assisted Coding in 2025
- 10 Common Misconceptions About Large Language Models
- Multi-Agent Systems: The Next Frontier in AI-Driven Cyber Defense
- ROC AUC vs Precision-Recall for Imbalanced Data
- 7 Scikit-learn Tricks for Optimized Cross-Validation
- A Gentle Introduction to Batch Normalization
- Small Language Models are the Future of Agentic AI
- 10 Python One-Liners Every Machine Learning Practitioner Should Know
- 3 Ways to Speed Up and Improve Your XGBoost Models
August 2025
- 5 Key Ways LLMs Can Supercharge Your Machine Learning Workflow
- 7 Pandas Tricks for Efficient Data Merging
- How to Decide Between Random Forests and Gradient Boosting
- A Gentle Introduction to Bayesian Regression
- 10 Useful NumPy One-Liners for Time Series Analysis
- Logistic vs SVM vs Random Forest: Which One Wins for Small Datasets?
- 5 Scikit-learn Pipeline Tricks to Supercharge Your Workflow
- Seeing Images Through the Eyes of Decision Trees
- 7 Pandas Tricks to Improve Your Machine Learning Model Development
- A Practical Guide to Handling Out-of-Memory Data in Python
- The Bias-Variance Trade-Off: A Visual Explainer
- How to Diagnose Why Your Classification Model Fails
- 7 NumPy Tricks You Didn’t Know You Needed
- 7 Matplotlib Tricks to Better Visualize Your Machine Learning Models
- Making Sense of Text with Decision Trees
- How to Interpret Your XGBoost Model: A Practical Guide to Feature Importance
- Grok’s Share and Claude’s Leak: 5 Things We Can Learn From System Prompts
- 7 Pandas Tricks for Time-Series Feature Engineering
- Time-Series Transformation Toolkit: Feature Engineering for Predictive Analytics
- A Gentle Introduction to Q-Learning
- Building a Decoder-Only Transformer Model Like Llama-2 and Llama-3
- Building a Transformer Model for Language Translation
July 2025
- How to Diagnose Why Your Regression Model Fails
- Implementing Advanced Feature Scaling Techniques in Python Step-by-Step
- Your First Containerized Machine Learning Deployment with Docker and FastAPI
- Building a Seq2Seq Model with Attention for Language Translation
- Beyond Pandas: 7 Advanced Data Manipulation Techniques for Large Datasets
- Image Augmentation Techniques to Boost Your CV Model Performance
- 10 Critical Mistakes that Silently Ruin Machine Learning Projects
- Zero-Shot and Few-Shot Classification with Scikit-LLM
- Building a Plain Seq2Seq Model for Language Translation
- Synthetic Dataset Generation with Faker
- From Linear Regression to XGBoost: A Side-by-Side Performance Comparison
- Feature Engineering with LLM Embeddings: Enhancing Scikit-learn Models
- Revisiting k-Means: 3 Approaches to Make It Work Better
- Discussing Decision Trees: What Makes a Good Split?
- 7 Pandas Tricks That Cut Your Data Prep Time in Half
- Word Embeddings for Tabular Data Feature Engineering
- Decision Trees Aren’t Just for Tabular Data
- 10 NumPy One-Liners to Simplify Feature Engineering
- Your First OpenAI API Project in Python Step-By-Step
- Securing FastAPI Endpoints for MLOps: An Authentication Guide
- Skip Connections in Transformer Models
- 5 Advanced RAG Architectures Beyond Traditional Methods
- Mixture of Experts Architecture in Transformer Models
June 2025
- Your First Local LLM API Project in Python Step-By-Step
- Linear Layers and Activation Functions in Transformer Models
- LayerNorm and RMS Norm in Transformer Models
- 7 AI Agent Frameworks for Machine Learning Workflows in 2025
- A Gentle Introduction to Attention Masking in Transformer Models
- 10 Essential Machine Learning Key Terms Explained
- Combining XGBoost and Embeddings: Hybrid Semantic Boosted Trees?
- A Gentle Introduction to Multi-Head Latent Attention (MLA)
- Converting Pandas DataFrames to PyTorch DataLoaders for Custom Deep Learning Model Training
- Beyond GridSearchCV: Advanced Hyperparameter Tuning Strategies for Scikit-learn Models
- A Gentle Introduction to Multi-Head Attention and Grouped-Query Attention
- 10 Must-Know Python Libraries for MLOps in 2025
- Unlocking Performance: Accelerating Pandas Operations with Polars
- 7 Concepts Behind Large Language Models Explained in 7 Minutes
- Interpolation in Positional Encodings and Using YaRN for Larger Context Window
- How to Combine Scikit-learn, CatBoost, and SHAP for Explainable Tree Models
- Positional Encodings in Transformer Models
- Advanced Feature Engineering Using Scikit-Learn Pipelines with Pandas’ ColumnTransformer and NumPy Arrays
- Navigating Imbalanced Datasets with Pandas and Scikit-learn
- Step-by-Step Guide to Deploying Machine Learning Models with FastAPI and Docker
- Implementing Vector Search from Scratch: A Step-by-Step Tutorial
- How to Optimize Language Model Size for Deployment
- Dealing with Missing Data Strategically: Advanced Imputation Techniques in Pandas and Scikit-learn
- Loss Functions Explained: Understand the Maths in Just 2 Minutes Each
- 10 MLOps Tools for Machine Learning Practitioners to Know
- NumPy Ninjutsu: Mastering Array Operations for High-Performance Machine Learning
- 10 Python One-Liners That Will Simplify Feature Engineering
- Word Embeddings in Language Models
May 2025
- A Gentle Introduction to SHAP for Tree-Based Models
- Using Quantized Models with Ollama for Application Development
- Tokenizers in Language Models
- 10 Python Libraries That Speed Up Model Development
- Selecting the Right Feature Engineering Strategy: A Decision Tree Approach
- Using NotebookLM as Your Machine Learning Study Guide
- Encoders and Decoders in Transformer Models
- A Gentle Introduction to Word Embedding and Text Vectorization
- Understanding OpenAI Codex CLI Commands
- 10 Underrated Books for Mastering Machine Learning
- 10 Python One-Liners for Feature Selection Like a Pro
- 5 Breakthrough Machine Learning Research Papers Already in 2025
- A Gentle Introduction to Learning Rate Schedulers
- Custom Fine-Tuning for Domain-Specific LLMs
- Roadmap to Python in 2025
- How to Combine Pandas, NumPy, and Scikit-learn Seamlessly
- Creating a Qwen-Powered Lightweight Personal Assistant
- Attention May Be All We Need… But Why?
- Creating a Secure Machine Learning API with FastAPI and Docker
- Zero-Shot and Few-Shot Learning with Reasoning LLMs
- Automate Dataset Labeling with Active Learning
April 2025
- 7 Emerging Trends in Generative AI and Their Real-World Impact
- 5 Problems Encountered Fine-Tuning LLMs with Solutions
- PyTorch Lightning Hyperparameter Optimization with Optuna
- Advanced Techniques to Build Your RAG System
- 10 Python One-Liners for Machine Learning Modeling
- Building RAG Systems with Transformers
- Let’s Build a RAG-Powered Research Paper Assistant
- 10 Must-Know Python Libraries for Machine Learning in 2025
- Understanding Text Generation Parameters in Transformers
- Further Applications with Context Vectors
- Building a RAG Pipeline with llama.cpp in Python
- Detecting & Handling Data Drift in Production
- Quantization in Machine Learning: 5 Reasons Why It Matters More Than You Think
- Applications with Context Vectors
- Generating and Visualizing Context Vectors in Transformers
- 5 Lessons Learned Building RAG Systems
- Understanding RAG Part X: RAG Pipelines in Production
- Understanding RAG Part IX: Fine-Tuning LLMs for RAG
- How to Perform Scikit-learn Hyperparameter Optimization with Optuna
- 5 Reasons Why Traditional Machine Learning is Alive and Well in the Age of LLMs
- Example Applications of Text Embedding
- Using Auto Classes in the Transformers Library
- Text Embedding Generation with Transformers
- The Beginner’s Guide to Clustering with Python
- The Roadmap for Mastering MLOps in 2025
- Fine-Tuning DistilBERT for Question Answering
- A Practical Guide to Building Local RAG Applications with LangChain
March 2025
- 3 Ways Vibe Coding and AI-Assisted Development Are 2 Different Things
- Advanced Q&A Features with DistilBERT
- A Gentle Introduction to Attention and Transformer Models
- Building a Recommender System From Scratch with Matrix Factorization in Python
- The Beginner’s Guide to Machine Learning with Rust
- A Gentle Introduction to Graph Neural Networks in Python
- 10 Must-Know Python Libraries for LLMs in 2025
- Implementing Multilingual Translation with T5 and Transformers
- Bias Detection in LLM Outputs: Statistical Approaches
- Building Q&A Systems with DistilBERT and Transformers
- Understanding RAG Part VIII: Mitigating Hallucinations in RAG
- 6 Lesser-Known Scikit-Learn Features That Will Save You Time
- Debugging PyTorch Machine Learning Models: A Step-by-Step Guide
- A Gentle Introduction to Transformers Library
- The Roadmap for Mastering Language Models in 2025
- Statistical Methods for Evaluating LLM Performance
- Understanding RAG Part VII: Vector Databases & Indexing Strategies
- Mastering Time Series Forecasting: From ARIMA to LSTM
- A Complete Guide to Matrices for Machine Learning with Python
- The Beginner’s Guide to Language Models with Python
- Understanding the DistilBart Model and ROUGE Metric
- Text Summarization with DistilBart Model
- Diagnosing and Fixing Overfitting in Machine Learning with Python
- Building LLM Applications with Hugging Face Endpoints and FastAPI
- 10 Python One-Liners That Will Boost Your Data Preparation Workflow
- Text Generation with GPT-2 Model
February 2025
- Auto-Completion Style Text Generation with GPT-2 Model
- Understanding RAG Part VI: Effective Retrieval Optimization
- Understanding Probability Distributions for Machine Learning with Python
- How to Do Named Entity Recognition (NER) with a BERT Model
- Understanding RAG Part V: Managing Context Length
- Integrating TensorFlow and NumPy for Custom Operations
- Prompt Engineering Patterns for Successful RAG Implementations
- Implementing Multi-Modal RAG Systems
- Next-Level Data Science (7-Day Mini-Course)
- Creating Custom Layers and Loss Functions in PyTorch
- The Role of Domain Knowledge in Machine Learning: Why Subject Matter Experts Matter
- 10 Useful LangChain Components for Your Next RAG System
- Building Your First Multi-Agent System: A Beginner’s Guide
- Time Series Forecasting with PyCaret: Building Multi-Step Prediction Model
- Automated Feature Engineering in PyCaret
- The 2025 Machine Learning Toolbox: Top Libraries and Tools for Practitioners
- A Complete Introduction to Using BERT Models
January 2025
- An Introduction to Logarithms in Machine Learning with Python
- Optimizing Memory Usage in PyTorch Models
- Creating Powerful Ensemble Models with PyCaret
- Kernel Methods in Machine Learning with Python
- YOU SEE AN LLM HERE: Integrating Language Models Into Your Text Adventure Games
- Understanding RAG Part IV: RAGAs & Other Evaluation Frameworks
- 3 Easy Ways to Fine-Tune Language Models
- 5 Python Libraries to Build an Optimized RAG System
- Future-Proof Your Machine Learning Career in 2025
- The Roadmap for Mastering Machine Learning in 2025
- Building a Custom Model Pipeline in PyCaret: From Data Prep to Production
- A Practical Guide to the Claude API
- RAG Hallucination Detection Techniques
- 5 Common Mistakes to Avoid When Training LLMs
- 7 Next-Generation Prompt Engineering Techniques
- LLM Evaluation Metrics Made Easy
- 7 Machine Learning Trends to Watch in 2025
2024 157
December 2024
- Machine Learning Salaries and Job Market Analysis for 2024 and Beyond
- 5 of the Most Influential Machine Learning Papers of 2024
- 6 Language Model Concepts Explained for Beginners
- 5 Tools for Visualizing Machine Learning Models
- 7 Machine Learning Projects For Beginners
- How to Quickly Deploy Machine Learning Models with Streamlit
- 10 Podcasts That Every Machine Learning Enthusiast Should Subscribe To
- The Ultimate Guide to Building a Machine Learning Portfolio That Lands Jobs
- Optimizing Machine Learning Models for Production: A Step-by-Step Guide
- 5 Beginner-Friendly Projects to Learn LLMs & RAG
- 5 Free APIs for Building AI Applications
- Machine Learning vs. Traditional Analytics: When to Use Which?
- Building a Graph RAG System: A Step-by-Step Approach
November 2024
- 5 Free Courses for Mastering LLMs
- The Beginner’s Guide to Natural Language Processing with Python
- Demystifying Ensemble Methods: Boosting, Bagging, and Stacking Explained
- A Practical Guide to Building Recommender Systems
- Building Your First Chatbot: A Hands-On Tutorial with Open-Source Tools
- 5 Tips for Avoiding Common Rookie Mistakes in Machine Learning Projects
- Mastering the Art of Hyperparameter Tuning: Tips, Tricks, and Tools
- A Practical Guide to Choosing the Right Algorithm for Your Problem: From Regression to Neural Networks
- Building a Robust Machine Learning Pipeline: Best Practices and Common Pitfalls
- Natural Language Generation Inside Out: Teaching Machines to Write Like Humans
- Industries in Focus: Machine Learning in Finance
October 2024
- Free Data and AI Courses with 365 Data Science—Unlimited Access until Nov 21
- 10 Python One-Liners That Will Boost Your Data Science Workflow
- Anomaly Detection Techniques in Large-Scale Datasets
- Leveraging Transfer Learning in Computer Vision for Quick Wins
- 7 Open-Source Machine Learning Projects You Can Contribute To Today
- Free AI-Powered Interview Preparation Tool by 365 Data Science
- Understanding RAG III: Fusion Retrieval and Reranking
- 5 Free Books on Computer Vision
- A Practical Guide to Deploying Machine Learning Models
- 7 Scikit-Learn Secrets You Probably Didn’t Know About
- Interpreting and Communicating Data Science Results
- Understanding RAG Part II: How Classic RAG Works
- From Features to Performance: Crafting Robust Predictive Models
- 5 Free Datasets to Kickstart Your Machine Learning Projects Today
- Understanding RAG Part I: Why It’s Needed
- Planning Your Data Science Project
- A Roadmap for Your Machine Learning Career
- 7 Free Machine Learning Tools Every Beginner Should Master in 2024
- CatBoost Essentials: Building Robust Home Price Prediction Systems
- 7 Machine Learning Algorithms Every Data Scientist Should Know
- 7 LLM Projects to Boost Your Machine Learning Portfolio
- Exploring LightGBM: Leaf-Wise Growth with GBDT and GOSS
- Industries in Focus: Machine Learning for Cybersecurity Threat Detection
September 2024
- Navigating Missing Data Challenges with XGBoost
- Building 3 Fun AI Applications with ControlFlow
- Boosting Over Bagging: Enhancing Predictive Accuracy with Gradient Boosting Regressors
- 5 Free Courses to Master Deep Learning in 2024
- From Single Trees to Forests: Enhancing Real Estate Predictions with Ensembles
- Decision Trees and Ordinal Encoding: A Practical Guide
- From Data to Insights: A Beginner’s Journey in Exploratory Data Analysis
- 5 Real-World Machine Learning Projects You Can Build This Weekend
- The Concise Guide to Feature Engineering for Better Model Performance
- Branching Out: Exploring Tree-Based Models for Regression
- Automating Data Cleaning Processes with Pandas
- Filling the Gaps: A Comparative Guide to Imputation Techniques in Machine Learning
- Comparing Scikit-Learn and TensorFlow for Machine Learning
- Scaling to Success: Implementing and Optimizing Penalized Models
- Tips for Using Machine Learning in Fraud Detection
- Detecting and Overcoming Perfect Multicollinearity in Large Datasets
- 5 Emerging AI Technologies That Will Shape the Future of Machine Learning
- Tips for Effective Feature Selection in Machine Learning
- The Power of Pipelines
- 10 Machine Learning Algorithms Explained Using Real-World Analogies
August 2024
- Interior Design with Stable Diffusion (8-day mini-course)
- Using R for Predictive Modeling in Finance
- 5 Influential Machine Learning Papers You Should Read
- 5 Groundbreaking Applications of Reinforcement Learning in 2024
- Everything You Need to Know About the Hugging Face Model Hub and Community
- 10 Must-Know Python Libraries for Machine Learning in 2024
- Capturing Curves: Advanced Modeling with Polynomial Regression
- A Gentle Introduction to Bayesian Statistics
- Interpreting Coefficients in Linear Regression Models
- Basic Statistical Analysis with NumPy
- 3 Ways of Using Gemma 2 Locally
- 7 Machine Learning Projects That Can Add Value to Any Resume
- One Hot Encoding: Understanding the “Hot” in Data
- The Search for the Sweet Spot in a Linear Regression with Numeric Features
- Free Tools Every ML Beginner Should Use
- 5 Free Podcasts That Demystify Machine Learning Concepts
- Building a Simple RAG Application Using LlamaIndex
- The Strategic Use of Sequential Feature Selector for Housing Price Predictions
- 5 Tips for Getting Started with Time Series Analysis
- From Train-Test to Cross-Validation: Advancing Your Model’s Evaluation
- Tips for Tuning Hyperparameters in Machine Learning Models
- Integrating Scikit-Learn and Statsmodels for Regression
July 2024
- 7 Free Resource to Master LLMs
- How to Use Stable Diffusion Effectively
- 7 Key Terms Every Machine Learning Beginner Should Know
- 5 DIY Python Functions for Data Cleaning
- Introduction to AutoML: Automating Machine Learning Workflows
- Using ControlNet with Stable Diffusion
- 5 Challenges in Machine Learning Adoption and How to Overcome Them
- Understanding LangChain LLM Output Parser
- Using Machine Learning in Customer Segmentation
- Tips for Effectively Training Your Machine Learning Models
- Principles of Reinforcement Learning: An Introduction with Python
- 5 Tips for Getting Started with Deep Learning
- Tips for Effective Feature Engineering in Machine Learning
- 5 Common Mistakes in Machine Learning and How to Avoid Them
June 2024
- Stable Diffusion Project: Reviving Old Photos
- The Ultimate Beginner’s Guide to Docker
- Stable Diffusion Project: Commercial Poster
- 5 Effective Ways to Handle Imbalanced Data in Machine Learning
- Tips for Choosing the Right Machine Learning Model for Your Data
- Stable Diffusion Project: Creating Illustration
- 5 Free Books on Machine Learning Algorithms You Must Read
- Stable Diffusion Project: Word Art
- 5 Free YouTube Channels Dedicated to Machine Learning Education
- Tips for Choosing the Right Machine Learning Course
- 5 Free Courses on Reinforcement Learning
- Training Stable Diffusion with Dreambooth
- 5 Free Resources for Understanding Neural Networks
- Fine-Tuning Stable Diffusion with LoRA
- 5 Free Datasets to Start Your Machine Learning Projects
- Inpainting and Outpainting with Diffusers
- 5 Free Platforms to Collaborate on Machine Learning Projects
- Further Stable Diffusion Pipeline with Diffusers
- 5 Useful Loss Functions
- Running Stable Diffusion with Python
- 5 Free Machine Learning Courses from Top Universities
May 2024
- Tips for Deploying Machine Learning Models Efficiently
- Beginning Data Science (7-day mini-course)
- Tips for Handling Imbalanced Data in Machine Learning
- 5 Essential Classification Algorithms Explained for Beginners
- 5 Essential Free Tools for Getting Started with LLMs
- More Prompting Techniques for Stable Diffusion
- Using OpenPose with Stable Diffusion
April 2024
- Inpainting and Outpainting with Stable Diffusion
- Generate Realistic Faces in Stable Diffusion
- Using LoRA in Stable Diffusion
- Prompting Techniques for Stable Diffusion
- How to Create Images Using Stable Diffusion Web UI
- A Technical Introduction to Stable Diffusion
- Brief Introduction to Diffusion Models for Image Generation
March 2024
- Unfolding Data Stories: From First Glance to In-Depth Analysis
- The Da Vinci Code of Data: Mastering The Data Science Mind Map
- Finding Value with Data: The Cohesive Force Behind Luxury Real Estate Decisions
- Skewness Be Gone: Transformative Tricks for Data Scientists
- Best Free Resources to Learn Data Analysis and Data Science
- Harmonizing Data: A Symphony of Segmenting, Concatenating, Pivoting, and Merging
- Beyond SQL: Transforming Real Estate Data into Actionable Insights with Pandas
February 2024
- Spotting the Exception: Classical Methods for Outlier Detection in Data Science
- Leveraging ANOVA and Kruskal-Wallis Tests to Analyze the Impact of the Great Recession on Housing Prices
- Garage or Not? Housing Insights Through the Chi-Squared Test for Ames, Iowa
- Testing Assumptions in Real Estate: A Dive into Hypothesis Testing with the Ames Housing Dataset
- Inferential Insights: How Confidence Intervals Illuminate the Ames Real Estate Market
- Mastering Pair Plots for Visualization and Hypothesis Creation in the Ames Housing Market
- Feature Relationships 101: Lessons from the Ames Housing Data
January 2024
- Exploring Dictionaries, Classifying Variables, and Imputing Data in the Ames Dataset
- From Data to Map: Visualizing Ames House Prices with Python
- Decoding Data: An Introduction to Descriptive Statistics with the Ames Housing Dataset
- Revealing the Invisible: Visualizing Missing Values in Ames Housing
- Machine Learning in OpenCV (7-Day Mini-Course)
2023 92
December 2023
- Logistic Regression for Image Classification Using OpenCV
- Logistic Regression in OpenCV
- Running a Neural Network Model in OpenCV
- Image Vector Representation for Machine Learning Using OpenCV
- K-Means Clustering in OpenCV and Application for Color Quantization
- Training a Haar Cascade Object Detector in OpenCV
- Using Haar Cascade for Object Detection
- Random Forest for Image Classification Using OpenCV
- Normal Bayes Classifier for Image Segmentation Using OpenCV
November 2023
- Support Vector Machines for Image Classification and Detection Using OpenCV
- Hardware-Accelerated AI for Windows Apps Using ONNX RT
- Support Vector Machines in OpenCV
- How to Train a Object Detection Engine with HOG in OpenCV
- Image Datasets for Practicing Machine Learning in OpenCV
- Extracting Histogram of Gradients with OpenCV
- Image Feature Extraction in OpenCV: Keypoints and Description Vectors
- Image Feature Extraction in OpenCV: Edges and Corners
- 365 Data Science Offers All Courses 100% Free for 2 Weeks
- K-Nearest Neighbors Classification Using OpenCV
- Fast and Cheap Fine-Tuned LLM Inference with LoRA Exchange (LoRAX)
October 2023
- K-Means Clustering for Image Classification Using OpenCV
- How to Transform Images and Create Video with OpenCV
- How to Read and Display Videos Using OpenCV
- How to Read, Write, Display Images in OpenCV and Converting Color Spaces
- A Gentle Introduction to OpenCV: An Open Source Library for Computer Vision and Machine Learning
September 2023
- Using ggplot2 for Visualization in R
- Exploring Data using dplyr in R
- A Gentle Introduction to Using R Markdown
- Statistical Tests in R
- Generating Random Numbers in R
- Plotting Graphs in R
August 2023
- Logic, Flow Control, and Functions in R
- Built-in Datasets in R
- Operations on Vectors in R
- Surviving in the R Environment
- A Gentle Introduction to Lists and Data Frames in R
- A Gentle Introduction to Vectors in R
- Celebrating Devart’s 26th Birthday with an Exclusive 20% Discount on Data Connectivity Tools!
- An Introduction to R
July 2023
- MOSTLY AI: The most accurate synthetic data generator
- Building Your mini-ChatGPT at Home
- Advanced Techniques for Research with ChatGPT
- Using the Natural Language Understanding Capability of ChatGPT
June 2023
- Creating a PowerPoint Presentation using ChatGPT
- Generating Diagrams with ChatGPT
- Using ChatGPT as Your Programming Assistant
- Using ChatGPT as Your Personalized Teacher
- Prompt Engineering for Effective Interaction with ChatGPT
- Mastering Summarization with ChatGPT
- Using ChatGPT for Translation Effectively
- Strategies for Effective Brainstorming with ChatGPT
- ChatGPT as Your Expert Helper
- A Gentle Introduction to Hallucinations in Large Language Models
May 2023
- A Gentle Introduction to Prompt Engineering
- Writing an Essay with ChatGPT
- What Are Zero-Shot Prompting and Few-Shot Prompting
- Get a Taste of LLMs from GPT4All
- What are Large Language Models
- Activation Functions in PyTorch
April 2023
- PyTorch Tutorial: How to Develop Deep Learning Models with Python
- Deep Learning with PyTorch (9-Day Mini-Course)
March 2023
- Building a Logistic Regression Classifier in PyTorch
- Training Logistic Regression with Cross-Entropy Loss in PyTorch
- Building an Image Classifier with a Single-Layer Neural Network in PyTorch
- Text Generation with LSTM in PyTorch
- LSTM for Time Series Prediction in PyTorch
- Handwritten Digit Recognition with LeNet5 Model in PyTorch
- Building a Convolutional Neural Network in PyTorch
- Visualizing a PyTorch Model
February 2023
- Managing a PyTorch Training Process with Checkpoints and Early Stopping
- Understand Model Behavior During Training by Visualizing Metrics
- Training a PyTorch Model with DataLoader and Dataset
- Using Learning Rate Schedule in PyTorch Training
- Using Dropout Regularization in PyTorch Models
- Loss Functions in PyTorch Models
- Using Activation Functions in Deep Learning Models
- Save and Load Your PyTorch Models
- How to Grid Search Hyperparameters for PyTorch Models
- Use PyTorch Deep Learning Models with scikit-learn
- Building a Regression Model in PyTorch
- Building a Binary Classification Model in PyTorch
- Building a Multiclass Classification Model in PyTorch
January 2023
- How to Evaluate the Performance of PyTorch Models
- Creating a Training Loop for PyTorch Models
- Develop Your First Neural Network with PyTorch, Step by Step
- Building Multilayer Perceptron Models in PyTorch
- Using Autograd in PyTorch to Solve a Regression Problem
- Manipulating Tensors in PyTorch
- Neural Network with More Hidden Neurons
- Building a Single Layer Neural Network in PyTorch
- Building a Softmax Classifier for Images in PyTorch
- Building Transformer Models with Attention Crash Course. Build a Neural Machine Translator in 12 Days
2022 118
December 2022
- Introduction to Softmax Classifier in PyTorch
- Initializing Weights for Deep Learning Models
- Making Predictions with Logistic Regression in PyTorch
- Training a Multi-Target Multilinear Regression Model in PyTorch
- Multi-Target Predictions with Multilinear Regression in PyTorch
- Training a Single Output Multilinear Regression Model in PyTorch
- Making Predictions with Multilinear Regression in PyTorch
- How do you generate synthetic data for machine learning and why do you need it?
- Training and Validation Data in PyTorch
- Using Optimizers from PyTorch
- Mini-Batch Gradient Descent and DataLoader in PyTorch
November 2022
- Implementing Gradient Descent in PyTorch
- Training a Linear Regression Model in PyTorch
- Making Linear Predictions in PyTorch
- Loading and Providing Datasets in PyTorch
- Using Dataset Classes in PyTorch
- Calculating Derivatives in PyTorch
- Two-Dimensional Tensors in Pytorch
- One-Dimensional Tensors in Pytorch
- 365 Data Science courses free until November 21
- Attend the Data Science Symposium 2022, November 8 in Cincinnati
October 2022
- A Brief Introduction to BERT
- Data Engineering for ML: Optimize for Cost Efficiency
- Interactive Machine Learning Live Course with Dr. Kirk Borne
- Inferencing the Transformer Model
- Plotting the Training and Validation Loss Curves for the Transformer Model
- Attend the Data Science Symposium 2022
- Training the Transformer Model
- Joining the Transformer Encoder and Decoder Plus Masking
- Implementing the Transformer Decoder from Scratch in TensorFlow and Keras
- Implementing the Transformer Encoder from Scratch in TensorFlow and Keras
- The Vision Transformer Model
September 2022
- How to Implement Multi-Head Attention from Scratch in TensorFlow and Keras
- How to Implement Scaled Dot-Product Attention from Scratch in TensorFlow and Keras
- The Transformer Positional Encoding Layer in Keras, Part 2
- TransformX by Scale AI is Oct 19-21: Register for free!
- A Gentle Introduction to Positional Encoding in Transformer Models, Part 1
- The Transformer Model
- The Transformer Attention Mechanism
- Understanding Simple Recurrent Neural Networks in Keras
- An Introduction to Recurrent Neural Networks and the Math That Powers Them
- The Luong Attention Mechanism
- The Bahdanau Attention Mechanism
- Adding a Custom Attention Layer to a Recurrent Neural Network in Keras
August 2022
- Join Doug Turnbull’s ‘ML Powered Search’ Live Cohort
- A Tour of Attention-Based Architectures
- The Attention Mechanism from Scratch
- What Is Attention?
- A Bird’s Eye View of Research on Attention
- How to Calculate Precision, Recall, F1, and More for Deep Learning Models
- Last call: Stefan Krawcyzk’s ‘Mastering MLOps’ Live Cohort
- How to Make Predictions with Keras
- Why Initialize a Neural Network with Random Weights?
- When to Use MLP, CNN, and RNN Neural Networks
- Difference Between a Batch and an Epoch in a Neural Network
- Using Depthwise Separable Convolutions in Tensorflow
July 2022
- Mastering MLOps: Live Model Deployment & Inference Course with Stefan Krawczyk
- Tepper Wants to Nerd Out On Data With You
- Image Augmentation with Keras Preprocessing Layers and tf.image
- Image Augmentation for Deep Learning with Keras
- Loss Functions in TensorFlow
- High-Fidelity Synthetic Data for Data Engineers and Data Scientists Alike
- Understanding the Design of a Convolutional Neural Network
- A Gentle Introduction to the tensorflow.data API
- Using Learning Rate Schedules for Deep Learning Models in Python with Keras
- Binary Classification Tutorial with the Keras Deep Learning Library
- Dropout Regularization in Deep Learning Models with Keras
- Using Activation Functions in Neural Networks
- How to Checkpoint Deep Learning Models in Keras
- How to Grid Search Hyperparameters for Deep Learning Models in Python with Keras
June 2022
- Three Ways to Build Machine Learning Models in Keras
- Evaluate the Performance of Deep Learning Models in Keras
- Using Autograd in TensorFlow to Solve a Regression Problem
- Overview of Some Deep Learning Libraries
- How to Build Multi-Layer Perceptron Neural Network Models with Keras
- How to Save and Load Your Keras Deep Learning Model
- Your First Deep Learning Project in Python with Keras Step-by-Step
- Using Normalization Layers to Improve Deep Learning Models
- Introduction to the Python Deep Learning Library TensorFlow
- Python for Machine Learning (7-day mini-course)
May 2022
- Developing a Python Program Using Inspection Tools
- Monkey Patching Python Code
- Logging in Python
- Profiling Python Code
- Static Analyzers in Python
- Setting Breakpoints and Exception Hooks in Python
- Using Kaggle in Machine Learning Projects
April 2022
- Techniques to Write Better Python Code
- Take Your Machine Learning Skills Global
- Google Colab for Machine Learning Projects
- Multiprocessing in Python
- Interactive Course on Optimizing Search Engines With Ricardo Baeza-Yates Starting May 10
- Web Frameworks for Your Python Projects
- A First Course on Deploying Python Projects
- 10 seats remaining | A series of live ML strategy workshops
- Guide to Iteratively Tuning GNNs
- Managing Data for Machine Learning Projects
- Web Crawling in Python
- Massaging Data Using Pandas
- Very Deep Neural Networks Explained in 40 Seconds
- Scientific Functions in NumPy and SciPy
- Win tickets to The AI Summit London 2022
- A Gentle Introduction to Decorators in Python
March 2022
- A Guide to Getting Datasets for Machine Learning in Python
- Interactive ML Strategy course with Foster Provost starting April 7
- A Guide to Obtaining Time Series Datasets in Python
- Data Visualization in Python with matplotlib, Seaborn, and Bokeh
- Calculus for Machine Learning (7-day mini-course)
- Exploring the Python Ecosystem
- A Gentle Introduction to Unit Testing in Python
- Data Science Notebook Life-Hacks I Learned From Ploomber
- A Gentle Introduction to Serialization for Python
February 2022
- Command Line Arguments for Your Python Script
- Easier Experimenting in Python
- Duck Typing, Scope, and Investigative Functions in Python
- Comments, Docstrings, and Type Hints in Python Code
- More Special Features in Python
January 2022
2021 123
December 2021
- Anomaly Detection with Isolation Forest and Kernel Density Estimation
- Running and Passing Information to a Python Script
- Understanding Traceback in Python
- Functional Programming in Python
- Python Classes and Their Use in Keras
- Some Language Features in Python
- Method of Lagrange Multipliers: The Theory Behind Support Vector Machines (Part 3: Implementing An SVM From Scratch In Python)
- Method of Lagrange Multipliers: The Theory Behind Support Vector Machines (Part 2: The Non-Separable Case)
November 2021
- Application of differentiations in neural networks
- Method of Lagrange Multipliers: The Theory Behind Support Vector Machines (Part 1: The Separable Case)
- Visualizing the vanishing gradient problem
- Using CNN for financial time series prediction
October 2021
- Face Recognition using Principal Component Analysis
- Using Singular Value Decomposition to Build a Recommender System
- A Gentle Introduction to Vector Space Models
- Principal Component Analysis for Visualization
- Optimization for Machine Learning Crash Course
September 2021
- How to Learn Python for Machine Learning
- Training-validation-test split and cross-validation done right
- A Gentle Introduction to Particle Swarm Optimization
August 2021
- Lagrange Multiplier Approach with Inequality Constraints
- A Gentle Introduction To Sigmoid Function
- Calculus in Action: Neural Networks
- A Gentle Introduction to Taylor Series
- A Gentle Introduction To Approximation
- The Chain Rule of Calculus – Even More Functions
- The Chain Rule of Calculus for Univariate and Multivariate Functions
- A Gentle Introduction To Method Of Lagrange Multipliers
- A Gentle Introduction to Optimization / Mathematical Programming
- A Gentle Introduction to the Laplacian
- A Gentle Introduction To Hessian Matrices
- A Gentle Introduction to the Jacobian
July 2021
- Higher-Order Derivatives
- A Gentle Introduction To Gradient Descent Procedure
- A Gentle Introduction To Partial Derivatives and Gradient Vectors
- A Gentle Introduction To Vector Valued Functions
- Differential and Integral Calculus – Differentiate with Respect to Anything
- A Gentle Introduction to Multivariate Calculus
- Applications of Derivatives
- A Gentle Introduction to Continuous Functions
- A Gentle Introduction to Indeterminate Forms and L’Hospital’s Rule
- The Power, Product and Quotient Rules
- Derivative of the Sine and Cosine
- A Gentle Introduction to Slopes and Tangents
- A Gentle Introduction to Derivatives of Powers and Polynomials
June 2021
- A Gentle Introduction to Function Derivatives
- A Gentle Introduction to Evaluating Limits
- A Gentle Introduction to Limits and Continuity
- What you need to know before you get started: A brief tour of Calculus Pre-Requisites
- Calculus in Machine Learning: Why it Works
- Key Concepts in Calculus: Rate of Change
- What is Calculus?
- Differential Evolution from Scratch in Python
- Modeling Pipeline Optimization With scikit-learn
- Gradient Descent With AdaGrad From Scratch
- Gradient Descent Optimization With AMSGrad From Scratch
- Gradient Descent Optimization With AdaMax From Scratch
- A Gentle Introduction to Premature Convergence
- Why Optimization Is Important in Machine Learning
May 2021
- A Gentle Introduction to Function Optimization
- One-Dimensional (1D) Test Functions for Function Optimization
- Line Search Optimization With Python
- Gradient Descent With RMSProp from Scratch
- Dual Annealing Optimization With Python
- A Gentle Introduction to the BFGS Optimization Algorithm
- Essence of Bootstrap Aggregation Ensembles
- A Gentle Introduction to Ensemble Diversity for Machine Learning
- A Gentle Introduction to Multiple-Model Machine Learning
- Essence of Boosting Ensembles for Machine Learning
- Ensemble Machine Learning With Python (7-Day Mini-Course)
- How to Develop a Weighted Average Ensemble With Python
- Strong Learners vs. Weak Learners in Ensemble Learning
April 2021
- A Gentle Introduction to Mixture of Experts Ensembles
- Growing and Pruning Ensembles in Python
- Dynamic Ensemble Selection (DES) for Classification in Python
- Essence of Stacking Ensembles for Machine Learning
- How to Combine Predictions for Ensemble Learning
- A Gentle Introduction to Ensemble Learning Algorithms
- How to Implement Gradient Descent Optimization from Scratch
- What Is a Gradient in Machine Learning?
- Gradient Descent With Adadelta from Scratch
- What Is Semi-Supervised Learning
- Develop a Neural Network for Cancer Survival Dataset
- Neural Network Models for Combined Classification and Regression
- Iterated Local Search From Scratch in Python
March 2021
- Develop a Neural Network for Woods Mammography Dataset
- Tune XGBoost Performance With Learning Curves
- Two-Dimensional (2D) Test Functions for Function Optimization
- How to Manually Optimize Machine Learning Model Hyperparameters
- A Gentle Introduction to XGBoost Loss Functions
- Gradient Descent Optimization With Nadam From Scratch
- Gradient Descent With Nesterov Momentum From Scratch
- Develop a Neural Network for Banknote Authentication
- XGBoost for Regression
- Basin Hopping Optimization in Python
- Random Search and Grid Search for Function Optimization
- How to Update Neural Network Models With More Data
- Simple Genetic Algorithm From Scratch in Python
February 2021
- Differential Evolution Global Optimization With Python
- Evolution Strategies From Scratch in Python
- Sensitivity Analysis of Dataset Size vs. Model Performance
- Prediction Intervals for Deep Learning Neural Networks
- Simulated Annealing From Scratch in Python
- No Free Lunch Theorem for Machine Learning
- A Gentle Introduction to Stochastic Optimization Algorithms
- How to Develop a Neural Net for Predicting Disturbances in the Ionosphere
- How to Use Optimization Algorithms to Manually Fit Regression Models
- Function Optimization With SciPy
- Gradient Descent With Momentum from Scratch
- Weight Initialization for Deep Learning Neural Networks
January 2021
- Difference Between Backpropagation and Stochastic Gradient Descent
- Local Optimization Versus Global Optimization
- How to Develop a Neural Net for Predicting Car Insurance Payout
- How to Use Nelder-Mead Optimization in Python
- How to Get Started With Recommender Systems
- Regression Metrics for Machine Learning
- How to Choose an Activation Function for Deep Learning
- Visualization for Function Optimization in Python
- Code Adam Optimization Algorithm From Scratch
- 3 Books on Optimization for Machine Learning
- Univariate Function Optimization in Python
- A Gentle Introduction to Machine Learning Modeling Pipelines
- Semi-Supervised Learning With Label Spreading
2020 158
December 2020
- Multinomial Logistic Regression With Python
- Semi-Supervised Learning With Label Propagation
- Histogram-Based Gradient Boosting Ensembles in Python
- Feature Selection with Stochastic Optimization Algorithms
- How to Choose an Optimization Algorithm
- Ensemble Learning Algorithm Complexity and Occam’s Razor
- What Is Meta-Learning in Machine Learning?
- Calculus Books for Machine Learning
- Dynamic Classifier Selection Ensembles in Python
- Perceptron Algorithm for Classification in Python
- Autoencoder Feature Extraction for Regression
- Autoencoder Feature Extraction for Classification
- How to Manually Optimize Neural Network Models
- Books on Genetic Programming
November 2020
- Blending Ensemble Machine Learning With Python
- How to Develop Random Forest Ensembles With XGBoost
- How to Develop a Light Gradient Boosted Machine (LightGBM) Ensemble
- Extreme Gradient Boosting (XGBoost) Ensemble in Python
- A Gentle Introduction to PyCaret for Machine Learning
- How to Develop a Feature Selection Subspace Ensemble in Python
- Develop a Bagging Ensemble with Different Data Transformations
- Multivariate Adaptive Regression Splines (MARS) in Python
- How to Identify Overfitting Machine Learning Models in Scikit-Learn
- Develop an Intuition for How Ensemble Learning Works
- Stochastic Hill Climbing in Python from Scratch
- Curve Fitting With Python
- Random Forest for Time Series Forecasting
October 2020
- How to Develop a Random Subspace Ensemble With Python
- Error-Correcting Output Codes (ECOC) for Machine Learning
- Why Use Ensemble Learning?
- A Gentle Introduction to Ensemble Learning
- 6 Books on Ensemble Learning
- Softmax Activation Function with Python
- How to Develop LARS Regression Models in Python
- Nearest Shrunken Centroids With Python
- How to Develop LASSO Regression Models in Python
- How to Develop Ridge Regression Models in Python
- How to Develop Elastic Net Regression Models in Python
- Robust Regression for Machine Learning in Python
- Gaussian Processes for Classification With Python
September 2020
- Radius Neighbors Classifier Algorithm With Python
- Linear Discriminant Analysis With Python
- How to Hill Climb the Test Set for Machine Learning
- How to Train to the Test Set in Machine Learning
- Multi-Core Machine Learning in Python With Scikit-Learn
- Automated Machine Learning (AutoML) Libraries for Python
- Combined Algorithm Selection and Hyperparameter Optimization (CASH Optimization)
- Hyperparameter Optimization With Random Search and Grid Search
- HyperOpt for Automated Machine Learning With Scikit-Learn
- TPOT for Automated Machine Learning in Python
- Auto-Sklearn for Automated Machine Learning in Python
- Scikit-Optimize for Hyperparameter Tuning in Machine Learning
- How to Use AutoKeras for Classification and Regression
August 2020
- Multi-Label Classification with Deep Learning
- Deep Learning Models for Multi-Output Regression
- Time Series Forecasting With Prophet in Python
- How to Set Axis for Rows and Columns in NumPy
- Hypothesis Test for Comparing Machine Learning Algorithms
- How to Calculate the Bias-Variance Trade-off with Python
- Why Do I Get Different Results Each Time in Machine Learning?
- Plot a Decision Surface for Machine Learning Algorithms in Python
- A Gentle Introduction to Computational Learning Theory
- How to use Seaborn Data Visualization for Machine Learning
- Multi-Class Imbalanced Classification
- How to Use XGBoost for Time Series Forecasting
- Repeated k-Fold Cross-Validation for Model Evaluation in Python
July 2020
- How to Configure k-Fold Cross-Validation
- Nested Cross-Validation for Machine Learning with Python
- LOOCV for Evaluating Machine Learning Algorithms
- Train-Test Split for Evaluating Machine Learning Algorithms
- How to Selectively Scale Numerical Input Variables for Machine Learning
- Add Binary Flags for Missing Values for Machine Learning
- How to Create Custom Data Transforms for Scikit-Learn
- How to Grid Search Data Preparation Techniques
- Framework for Data Preparation Techniques in Machine Learning
- 6 Dimensionality Reduction Algorithms With Python
- 4 Automatic Outlier Detection Algorithms in Python
- How to Use Feature Extraction on Tabular Data for Machine Learning
- How to Choose Data Preparation Methods for Machine Learning
June 2020
- 8 Top Books on Data Cleaning and Feature Engineering
- Data Preparation for Machine Learning (7-Day Mini-Course)
- Feature Engineering and Selection (Book Review)
- kNN Imputation for Missing Values in Machine Learning
- How to Avoid Data Leakage When Performing Data Preparation
- Tour of Data Preparation Techniques for Machine Learning
- What Is Data Preparation in a Machine Learning Project
- Why Data Preparation Is So Important in Machine Learning
- Ordinal and One-Hot Encodings for Categorical Data
- How to Use StandardScaler and MinMaxScaler Transforms in Python
- How to Perform Feature Selection for Regression Data
- How to Perform Feature Selection With Numerical Input Data
- Iterative Imputation for Missing Values in Machine Learning
May 2020
- Test-Time Augmentation For Tabular Data With Scikit-Learn
- How to Use Polynomial Feature Transforms for Machine Learning
- How to Scale Data With Outliers for Machine Learning
- Recursive Feature Elimination (RFE) for Feature Selection in Python
- How to Use Discretization Transforms for Machine Learning
- How to Use Quantile Transforms for Machine Learning
- How to Use Power Transforms for Machine Learning
- Statistical Imputation for Missing Values in Machine Learning
- Linear Discriminant Analysis for Dimensionality Reduction in Python
- Singular Value Decomposition for Dimensionality Reduction in Python
- Principal Component Analysis for Dimensionality Reduction in Python
- Introduction to Dimensionality Reduction for Machine Learning
- How to Develop a Gradient Boosting Machine Ensemble in Python
April 2020
- How to Develop an AdaBoost Ensemble in Python
- Difference Between Algorithm and Model in Machine Learning
- How to Develop a Bagging Ensemble with Python
- A Gentle Introduction to Degrees of Freedom in Machine Learning
- How to Develop an Extra Trees Ensemble with Python
- How to Develop a Random Forest Ensemble in Python
- How to Develop Voting Ensembles With Python
- How to Handle Big-p, Little-n (p >> n) in Machine Learning
- One-vs-Rest and One-vs-One for Multi-Class Classification
- Stacking Ensemble Machine Learning With Python
- 4 Types of Classification Tasks in Machine Learning
- 10 Clustering Algorithms With Python
- What Is Argmax in Machine Learning?
March 2020
- Gradient Boosting with Scikit-Learn, XGBoost, LightGBM, and CatBoost
- How to Calculate Feature Importance With Python
- How to Develop Multi-Output Regression Models with Python
- 4 Distance Measures for Machine Learning
- How to Perform Data Cleaning for Machine Learning with Python
- Neural Networks are Function Approximation Algorithms
- Imbalanced Multiclass Classification with the E.coli Dataset
- Imbalanced Multiclass Classification with the Glass Identification Dataset
- Imbalanced Classification with the Fraudulent Credit Card Transactions Dataset
- Step-By-Step Framework for Imbalanced Classification Projects
- Imbalanced Classification with the Adult Income Dataset
- Predictive Model for the Phoneme Imbalanced Classification Dataset
- Imbalanced Classification Model to Detect Mammography Microcalcifications
February 2020
- Develop a Model for the Imbalanced Classification of Good and Bad Credit
- How to Calibrate Probabilities for Imbalanced Classification
- A Gentle Introduction to the Fbeta-Measure for Machine Learning
- How to Develop an Imbalanced Classification Model to Detect Oil Spills
- How to Develop a Probabilistic Model of Breast Cancer Patient Survival
- Why Is Imbalanced Classification Difficult?
- One-Class Classification Algorithms for Imbalanced Datasets
- Bagging and Random Forest for Imbalanced Classification
- A Gentle Introduction to Threshold-Moving for Imbalanced Classification
- Cost-Sensitive Learning for Imbalanced Classification
- How to Configure XGBoost for Imbalanced Classification
- How to Develop a Cost-Sensitive Neural Network for Imbalanced Classification
January 2020
- Cost-Sensitive SVM for Imbalanced Classification
- Cost-Sensitive Decision Trees for Imbalanced Classification
- Cost-Sensitive Logistic Regression for Imbalanced Classification
- Tour of Data Sampling Methods for Imbalanced Classification
- How to Combine Oversampling and Undersampling for Imbalanced Classification
- Undersampling Algorithms for Imbalanced Classification
- SMOTE for Imbalanced Classification with Python
- Imbalanced Classification With Python (7-Day Mini-Course)
- Random Oversampling and Undersampling for Imbalanced Classification
- What Is the Naive Classifier for Each Imbalanced Classification Metric?
- How to Fix k-Fold Cross-Validation for Imbalanced Classification
- A Gentle Introduction to Probability Metrics for Imbalanced Classification
- Tour of Evaluation Metrics for Imbalanced Classification
- ROC Curves and Precision-Recall Curves for Imbalanced Classification
- How to Calculate Precision, Recall, and F-Measure for Imbalanced Classification
2019 171
December 2019
- Failure of Classification Accuracy for Imbalanced Class Distributions
- Standard Machine Learning Datasets for Imbalanced Classification
- Develop an Intuition for Severely Skewed Class Distributions
- Best Resources for Imbalanced Classification
- A Gentle Introduction to Imbalanced Classification
- How to Use the ColumnTransformer for Data Preparation
- TensorFlow 2 Tutorial: Get Started in Deep Learning with tf.keras
- Best Results for Standard Machine Learning Datasets
- Arithmetic, Geometric, and Harmonic Means for Machine Learning
- How to Transform Target Variables for Regression in Python
- Tune Hyperparameters for Classification Machine Learning Algorithms
- How to Develop Super Learner Ensembles in Python
- Develop an Intuition for Bayes Theorem With Worked Examples
- How to Use Out-of-Fold Predictions in Machine Learning
- A Gentle Introduction to the Bayes Optimal Classifier
- A Gentle Introduction to Model Selection for Machine Learning
November 2019
- How to Use an Empirical Distribution Function in Python
- How to Choose a Feature Selection Method For Machine Learning
- How to Perform Feature Selection with Categorical Data
- 3 Ways to Encode Categorical Variables for Deep Learning
- How to Save and Reuse Data Preparation Objects in Scikit-Learn
- What Does Stochastic Mean in Machine Learning?
- How to Connect Model Input Data With Predictions for Machine Learning
- How to Save a NumPy Array to File for Machine Learning
- 14 Different Types of Learning in Machine Learning
- A Gentle Introduction to Maximum a Posteriori (MAP) for Machine Learning
- A Gentle Introduction to Markov Chain Monte Carlo for Probability
- A Gentle Introduction to Monte Carlo Sampling for Probability
October 2019
- A Gentle Introduction to Expectation-Maximization (EM Algorithm)
- Probabilistic Model Selection with AIC, BIC, and MDL
- A Gentle Introduction to Logistic Regression With Maximum Likelihood Estimation
- A Gentle Introduction to Linear Regression With Maximum Likelihood Estimation
- Develop k-Nearest Neighbors in Python From Scratch
- A Gentle Introduction to Maximum Likelihood Estimation for Machine Learning
- A Gentle Introduction to Cross-Entropy for Machine Learning
- Naive Bayes Classifier From Scratch in Python
- How to Calculate the KL Divergence for Machine Learning
- Information Gain and Mutual Information for Machine Learning
- A Gentle Introduction to Information Entropy
- A Gentle Introduction to Bayesian Belief Networks
- How to Implement Bayesian Optimization from Scratch in Python
- How to Develop a Naive Bayes Classifier from Scratch in Python
- A Gentle Introduction to Bayes Theorem for Machine Learning
- Probability for Machine Learning (7-Day Mini-Course)
- How to Develop an Intuition for Probability With Worked Examples
September 2019
- How to Develop an Intuition for Joint, Marginal, and Conditional Probability
- A Gentle Introduction to Joint, Marginal, and Conditional Probability
- A Gentle Introduction to Probability Density Estimation
- Continuous Probability Distributions for Machine Learning
- Discrete Probability Distributions for Machine Learning
- A Gentle Introduction to Probability Distributions
- What Is Probability?
- A Gentle Introduction to Uncertainty in Machine Learning
- 5 Reasons to Learn Probability for Machine Learning
- Resources for Getting Started With Probability in Machine Learning
- How to Develop and Evaluate Naive Classifier Strategies Using Probability
- A Gentle Introduction to Jensen’s Inequality
- A Gentle Introduction to Generative Adversarial Network Loss Functions
August 2019
- How to Implement the Frechet Inception Distance (FID) for Evaluating GANs
- How to Implement the Inception Score (IS) for Evaluating GANs
- How to Evaluate Generative Adversarial Networks
- A Gentle Introduction to BigGAN the Big Generative Adversarial Network
- 9 Books on Generative Adversarial Networks (GANs)
- A Gentle Introduction to StyleGAN the Style Generative Adversarial Network
- What is Deep Learning?
- How to Train a Progressive Growing GAN in Keras for Synthesizing Faces
- How to Implement Progressive Growing GAN Models in Keras
- A Tour of Machine Learning Algorithms
- A Gentle Introduction to the Progressive Growing GAN
- How to Develop a CycleGAN for Image-to-Image Translation with Keras
- How to Implement CycleGAN Models From Scratch With Keras
- A Gentle Introduction to CycleGAN for Image Translation
- How to Develop a Pix2Pix GAN for Image-to-Image Translation
July 2019
- How to Implement Pix2Pix GAN Models From Scratch With Keras
- A Gentle Introduction to Pix2Pix Generative Adversarial Network
- How to Develop a Least Squares Generative Adversarial Network (LSGAN) in Keras
- How to Implement a Semi-Supervised GAN (SGAN) From Scratch in Keras
- How to Develop an Information Maximizing GAN (InfoGAN) in Keras
- How to Develop an Auxiliary Classifier GAN (AC-GAN) From Scratch with Keras
- How to Develop a Wasserstein Generative Adversarial Network (WGAN) From Scratch
- How to Implement Wasserstein Loss for Generative Adversarial Networks
- How to Code the GAN Training Algorithm and Loss Functions
- How to Get Started With Generative Adversarial Networks (7-Day Mini-Course)
- A Tour of Generative Adversarial Network Models
- How to Identify and Diagnose GAN Failure Modes
- How to Develop a Conditional GAN (cGAN) From Scratch
- How to Explore the GAN Latent Space When Generating Faces
June 2019
- How to Develop a GAN to Generate CIFAR10 Small Color Photographs
- How to Develop a GAN for Generating MNIST Handwritten Digits
- How to Develop a Deep Learning Photo Caption Generator from Scratch
- How to Develop a 1D Generative Adversarial Network From Scratch in Keras
- How to use the UpSampling2D and Conv2DTranspose Layers in Keras
- How to Implement GAN Hacks in Keras to Train Stable Models
- Tips for Training Stable Generative Adversarial Networks
- A Gentle Introduction to Generative Adversarial Networks (GANs)
- 18 Impressive Applications of Generative Adversarial Networks (GANs)
- Best Resources for Getting Started With GANs
- One-Shot Learning for Face Recognition
- How to Develop a Face Recognition System Using FaceNet in Keras
- How to Perform Face Recognition With VGGFace2 in Keras
- How to Perform Face Detection with Deep Learning
May 2019
- A Gentle Introduction to Deep Learning for Face Recognition
- How to Train an Object Detection Model with Keras
- How to Perform Object Detection With YOLOv3 in Keras
- How to Use Mask R-CNN in Keras for Object Detection in Photographs
- A Gentle Introduction to Object Recognition With Deep Learning
- Multi-Label Classification of Satellite Photos of the Amazon Rainforest
- How to Classify Photos of Dogs and Cats (with 97% accuracy)
- Transfer Learning in Keras with Computer Vision Models
- How to Develop a CNN From Scratch for CIFAR-10 Photo Classification
- Deep Learning CNN for Fashion-MNIST Clothing Classification
- How to Develop a CNN for MNIST Handwritten Digit Classification
- How to Visualize Filters and Feature Maps in Convolutional Neural Networks
- Best Practices for Preparing and Augmenting Image Data for CNNs
April 2019
- A Gentle Introduction to the ImageNet Challenge (ILSVRC)
- A Gentle Introduction to 1×1 Convolutions to Manage Model Complexity
- How to Develop VGG, Inception and ResNet Modules from Scratch in Keras
- Convolutional Neural Network Model Innovations for Image Classification
- A Gentle Introduction to Pooling Layers for Convolutional Neural Networks
- A Gentle Introduction to Padding and Stride for Convolutional Neural Networks
- How Do Convolutional Layers Work in Deep Learning Neural Networks?
- How to Use Test-Time Augmentation to Make Better Predictions
- How to Configure Image Data Augmentation in Keras
- How to Load Large Datasets From Directories for Deep Learning in Keras
- How to Get Started With Deep Learning for Computer Vision (7-Day Mini-Course)
- How to Load and Visualize Standard Computer Vision Datasets With Keras
- A Gentle Introduction to Channels-First and Channels-Last Image Formats
- How to Normalize, Center, and Standardize Image Pixels in Keras
March 2019
- How to Load, Convert, and Save Images With the Keras API
- How to Evaluate Pixel Scaling Methods for Image Classification With CNNs
- A Gentle Introduction to the Promise of Deep Learning for Computer Vision
- How to Manually Scale Image Pixel Data for Deep Learning
- How to Load and Manipulate Images for Deep Learning in Python With PIL/Pillow
- Stanford Convolutional Neural Networks for Visual Recognition Course (Review)
- A Gentle Introduction to Computer Vision
- DeepLearning.AI Convolutional Neural Networks Course (Review)
- 8 Books for Getting Started With Computer Vision
- 9 Applications of Deep Learning for Computer Vision
- How to Develop Competence With Deep Learning for Computer Vision
- How to Demonstrate Your Basic Skills with Deep Learning
- 3 Levels of Deep Learning Competence
- What is a Hypothesis in Machine Learning?
February 2019
- Why Training a Neural Network Is Hard
- How to use Learning Curves to Diagnose Machine Learning Model Performance
- How to Fix FutureWarning Messages in scikit-learn
- Recommendations for Deep Learning Neural Network Practitioners
- 8 Tricks for Configuring Backpropagation to Train Better Neural Networks
- Neural Networks: Tricks of the Trade Review
- How to Get Better Deep Learning Results (7-Day Mini-Course)
- A Gentle Introduction to the Challenge of Training Deep Learning Neural Network Models
- How to Control Neural Network Model Capacity With Nodes and Layers
- Framework for Better Deep Learning
- Your First Machine Learning Project in Python Step-By-Step
- How to Improve Performance With Transfer Learning for Deep Learning Neural Networks
- How to Avoid Exploding Gradients With Gradient Clipping
- How to use Data Scaling Improve Deep Learning Model Stability and Performance
January 2019
- How to Use Greedy Layer-Wise Pretraining in Deep Learning Neural Networks
- How to Choose Loss Functions When Training Deep Learning Neural Networks
- Loss and Loss Functions for Training Deep Learning Neural Networks
- Understand the Impact of Learning Rate on Neural Network Performance
- How to Configure the Learning Rate When Training Deep Learning Neural Networks
- How to Control the Stability of Training Neural Networks With the Batch Size
- How to Accelerate Learning of Deep Neural Networks With Batch Normalization
- Practical Deep Learning for Coders (Review)
- A Gentle Introduction to Batch Normalization for Deep Neural Networks
- 3 Must-Own Books for Deep Learning Practitioners
- How to Fix the Vanishing Gradients Problem Using the ReLU
- A Gentle Introduction to the Rectified Linear Unit (ReLU)
- Ensemble Neural Network Model Weights in Keras (Polyak Averaging)
- Snapshot Ensemble Deep Learning Neural Network in Python
- Impact of Dataset Size on Deep Learning Model Skill And Performance Estimates
2018 152
December 2018
- Stacking Ensemble for Deep Learning Neural Networks in Python
- How to Develop a Weighted Average Ensemble for Deep Learning Neural Networks
- How to Develop a Horizontal Voting Deep Learning Ensemble to Reduce Variance
- How to Create a Bagging Ensemble of Deep Learning Models in Keras
- How to Develop an Ensemble of Deep Learning Models in Keras
- Ensemble Learning Methods for Deep Learning Neural Networks
- How to Avoid Overfitting in Deep Learning Neural Networks
- How to Improve Deep Learning Model Robustness by Adding Noise
- Train Neural Networks With Noise to Reduce Overfitting
- Use Early Stopping to Halt the Training of Neural Networks At the Right Time
- A Gentle Introduction to Early Stopping to Avoid Overtraining Neural Networks
- How to Reduce Overfitting With Dropout Regularization in Keras
- A Gentle Introduction to Dropout for Regularizing Deep Neural Networks
November 2018
- How to Reduce Generalization Error With Activity Regularization in Keras
- A Gentle Introduction to Activation Regularization in Deep Learning
- How to Reduce Overfitting Using Weight Constraints in Keras
- A Gentle Introduction to Weight Constraints in Deep Learning
- How to Use Weight Decay to Reduce Overfitting of Neural Network in Keras
- Use Weight Regularization to Reduce Overfitting of Deep Learning Models
- How to Grid Search Deep Learning Models for Time Series Forecasting
- How to Develop LSTM Models for Time Series Forecasting
- How to Develop Convolutional Neural Network Models for Time Series Forecasting
- How to Develop Multilayer Perceptron Models for Time Series Forecasting
- How to Use the TimeseriesGenerator for Time Series Forecasting in Keras
- A Gentle Introduction to LSTM Autoencoders
- LSTM Model Architecture for Rare Event Time Series Forecasting
October 2018
- Comparing Classical and Machine Learning Algorithms for Time Series Forecasting
- Deep Learning Models for Univariate Time Series Forecasting
- How to Grid Search Naive Methods for Univariate Time Series Forecasting
- How to Grid Search SARIMA Hyperparameters for Time Series Forecasting
- How to Grid Search Triple Exponential Smoothing for Time Series Forecasting in Python
- How to Develop Multivariate Multi-Step Time Series Forecasting Models for Air Pollution
- How to Develop Multi-Step Time Series Forecasting Models for Air Pollution
- How to Develop Baseline Forecasts for Multi-Site Multivariate Air Pollution Time Series Forecasting
- How to Load, Visualize, and Explore a Multivariate Multistep Time Series Dataset
- Multi-Step LSTM Time Series Forecasting Models for Power Usage
- Convolutional Neural Networks for Multi-Step Time Series Forecasting
- Multi-step Time Series Forecasting with Machine Learning for Electricity Usage
- Autoregression Forecast Model for Household Electricity Consumption
September 2018
- Evaluate Naive Models for Forecasting Household Electricity Consumption
- How to Load and Explore Household Electricity Usage Data
- Deep Learning Models for Human Activity Recognition
- LSTMs for Human Activity Recognition Time Series Classification
- 1D Convolutional Neural Network Models for Human Activity Recognition
- Evaluate Machine Learning Algorithms for Human Activity Recognition
- How to Model Human Activity From Smartphone Data
- How to Develop a Framework to Spot-Check Machine Learning Algorithms in Python
- A Gentle Introduction to a Standard Human Activity Recognition Problem
- Indoor Movement Time Series Classification with Machine Learning Algorithms
- Probabilistic Forecasting Model to Predict Air Pollution Days
- A Gentle Introduction to Probability Scoring Methods in Python
- How to Get Started with Deep Learning for Time Series Forecasting (7-Day Mini-Course)
- How and When to Use a Calibrated Classification Model with scikit-learn
August 2018
- How to Use ROC Curves and Precision-Recall Curves for Classification in Python
- How to Predict Room Occupancy Based on Environmental Factors
- Predict Whether a Persons Eyes are Open or Closed Using Brain Waves
- How to Model Volatility with ARCH and GARCH for Time Series Forecasting in Python
- 4 Common Machine Learning Data Transforms for Time Series Forecasting
- A Gentle Introduction to Exponential Smoothing for Time Series Forecasting in Python
- A Gentle Introduction to SARIMA for Time Series Forecasting in Python
- 17 Statistical Hypothesis Tests in Python (Cheat Sheet)
- How to Reduce Variance in a Final Machine Learning Model
- How to Develop a Skillful Machine Learning Time Series Forecasting Model
- Taxonomy of Time Series Forecasting Problems
- 11 Classical Time Series Forecasting Methods in Python (Cheat Sheet)
- Statistics for Machine Learning (7-Day Mini-Course)
July 2018
- How to Code the Student’s t-Test from Scratch in Python
- How to Configure the Number of Layers and Nodes in a Neural Network
- How to Calculate McNemar’s Test to Compare Two Machine Learning Classifiers
- The Role of Randomization to Address Confounding Variables in Machine Learning
- All of Statistics for Machine Learning
- A Gentle Introduction to Statistical Power and Power Analysis in Python
- A Gentle Introduction to Effect Size Measures in Python
- How to Calculate Nonparametric Rank Correlation in Python
- Statistics in Plain English for Machine Learning
- How to Generate Random Numbers in Python
- Statistics for Evaluating Machine Learning Models
June 2018
- The Close Relationship Between Applied Statistics and Machine Learning
- What is Statistics (and why is it important in machine learning)?
- 10 Examples of How to Use Statistical Methods in a Machine Learning Project
- Controlled Experiments in Machine Learning
- Statistical Significance Tests for Comparing Machine Learning Algorithms
- A Gentle Introduction to the Chi-Squared Test for Machine Learning
- How to Calculate the 5-Number Summary for Your Data in Python
- A Gentle Introduction to Statistical Sampling and Resampling
- How to Calculate Critical Values for Statistical Hypothesis Testing with Python
- A Gentle Introduction to Statistical Data Distributions
- A Gentle Introduction to Data Visualization Methods in Python
- A Gentle Introduction to Estimation Statistics for Machine Learning
May 2018
- A Gentle Introduction to Statistical Tolerance Intervals in Machine Learning
- Prediction Intervals for Machine Learning
- Confidence Intervals for Machine Learning
- A Gentle Introduction to the Bootstrap Method
- A Gentle Introduction to k-fold Cross-Validation
- How to Transform Data to Better Fit The Normal Distribution
- How to Calculate Parametric Statistical Hypothesis Tests in Python
- How to Calculate Nonparametric Statistical Hypothesis Tests in Python
- A Gentle Introduction to Statistical Hypothesis Testing
- A Gentle Introduction to Normality Tests in Python
- A Gentle Introduction to Nonparametric Statistics
- Statistics Books for Machine Learning
- A Gentle Introduction to the Central Limit Theorem for Machine Learning
- A Gentle Introduction to the Law of Large Numbers in Machine Learning
April 2018
- A Gentle Introduction to Calculating Normal Summary Statistics
- How to Calculate Correlation Between Variables in Python
- How to Remove Outliers for Machine Learning
- Introduction to Random Number Generators for Machine Learning in Python
- How To Know if Your Machine Learning Model Has Good Performance
- The Model Performance Mismatch Problem (and what to do about it)
- How to Get the Most From Your Machine Learning Data
- Analytical vs Numerical Solutions in Machine Learning
- Machine Learning Development Environment
- How to Make Predictions with scikit-learn
- So, You are Working on a Machine Learning Problem…
- How to Think About Machine Learning
March 2018
- Comparing 13 Algorithms on 165 Datasets (hint: use Gradient Boosting)
- Why Machine Learning Does Not Have to Be So Hard
- Basics of Mathematical Notation for Machine Learning
- Linear Algebra for Machine Learning (7-Day Mini-Course)
- Computational Linear Algebra for Coders Review
- Linear Algebra for Deep Learning
- A Gentle Introduction to Sparse Matrices for Machine Learning
- A Gentle Introduction to Broadcasting with NumPy Arrays
- 10 Examples of Linear Algebra in Machine Learning
- No Bullshit Guide To Linear Algebra Review
- How to Solve Linear Regression Using Linear Algebra
- How to Calculate Principal Component Analysis (PCA) from Scratch in Python
February 2018
- A Gentle Introduction to Expected Value, Variance, and Covariance with NumPy
- How to Calculate the SVD from Scratch with Python
- Linear Algebra Cheat Sheet for Machine Learning
- Top Resources for Learning Linear Algebra for Machine Learning
- Gentle Introduction to Eigenvalues and Eigenvectors for Machine Learning
- A Gentle Introduction to Matrix Factorization for Machine Learning
- A Gentle Introduction to Tensors for Machine Learning with NumPy
- A Gentle Introduction to Matrix Operations for Machine Learning
- Matrix Types in Linear Algebra for Machine Learning
- Introduction to Matrices and Matrix Arithmetic for Machine Learning
- Gentle Introduction to Vector Norms in Machine Learning
- A Gentle Introduction to Vectors for Machine Learning
January 2018
- A Gentle Introduction to NumPy Arrays in Python
- 5 Reasons to Learn Linear Algebra for Machine Learning
- A Gentle Introduction to Linear Algebra
- Why Do Machine Learning Algorithms Work on New Data?
- How to Run Deep Learning Experiments on a Linux Server
- A Standard Multivariate, Multi-Step, and Multi-Site Time Series Forecasting Problem
- How to Install XGBoost for Python on macOS
- How to Generate Test Datasets in Python with scikit-learn
- How to Develop a Multichannel CNN Model for Text Classification
- How to Develop a Neural Machine Translation System from Scratch
- How to Prepare a French-to-English Dataset for Machine Translation
- How to Implement a Beam Search Decoder for Natural Language Processing
- How to Configure an Encoder-Decoder Model for Neural Machine Translation