> ## Documentation Index
> Fetch the complete documentation index at: https://resources.devweekends.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Machine Learning Mastery
> Learn machine learning the right way - starting with problems you already understand
# Machine Learning Mastery
## The Course That Makes ML Click
**This isn't just another ML course.** It's designed to take you from "I've heard of machine learning" to "I build production ML systems" through a carefully crafted journey that prioritizes understanding over memorization.
> **50+ Hours of Content**
>
> 26 comprehensive modules with projects, exercises, and real-world applications
> **10 Portfolio Projects**
>
> Build real ML systems you can showcase to employers
> **Industry-Ready Skills**
>
> Learn the same tools and techniques used at top tech companies
***
## You Already Think Like a Machine Learning Engineer
Before we write a single line of code, let me prove something to you.
### The House Price Game
Imagine you're helping a friend buy a house. They show you a listing:
**House A**: 3 bedrooms, 2 bathrooms, 1,800 sq ft, good school district, 15 years old
Your brain immediately does something remarkable. Based on houses you've seen before, you estimate: *"Probably around \$450,000?"*
Now they show you another:
**House B**: 5 bedrooms, 4 bathrooms, 3,500 sq ft, excellent school district, brand new
You think: *"Maybe \$850,000?"*
**Congratulations. You just did machine learning.**
You:
1. **Learned from examples** (houses you've seen before with their prices)
2. **Identified patterns** (more bedrooms = higher price, newer = higher price)
3. **Made predictions** on new, unseen data
That's literally all machine learning is. Think of it like learning to cook -- you don't memorize every recipe, you learn patterns (high heat = crispy, low heat = tender) and apply them to new ingredients. ML does the same thing, but with numbers instead of taste buds.
> [!NOTE]
>
> **Estimated Time**: 50-60 hours total\
> **Difficulty**: Beginner-friendly (we assume no ML background)\
> **Prerequisites**: Basic Python (variables, loops, functions)\
> **What You'll Build**: Real predictive models on real data\
> **Modules**: 24 comprehensive chapters from basics to production\
> **Math Required**: We'll teach you as we go, with links to our [Linear Algebra](https://resources.devweekends.com/courses/math-for-ml-linear-algebra/01-introduction.md) and [Calculus](https://resources.devweekends.com/courses/math-for-ml-calculus/00-introduction.md) courses
***
## The Core Question of ML
Every machine learning problem boils down to one question:
**"Given things I know, can I predict something I don't know?"**
| What You Know | What You Want to Predict | ML Name |
| - | - | - |
| House features | House price | Regression |
| Email text | Spam or not spam | Classification |
| Customer history | Will they buy again? | Classification |
| Movie preferences | Movie rating (1-5) | Regression |
| Photo pixels | Is it a cat or dog? | Classification |
| Purchase patterns | What else they might buy | Recommendation |
***
## Why This Course Is Different
Most ML courses start with math formulas, confusing Greek symbols, and abstract theory.
We start with **problems you already understand**:
* How would you predict house prices?
* How would you decide if an email is spam?
* How would you recommend movies to someone?
Then we show you that the math is just **formalizing what you already do naturally**.
> [!WARNING]
>
> **Real Talk**: You don't need a PhD to do ML. You need:
>
> 1. Curiosity about patterns
> 2. Willingness to experiment
> 3. Patience to iterate
>
> If you can estimate house prices in your head, you can learn ML.
***
## ๐ฏ What You'll Be Able to Do After This Course
**1. Build ML Models from Scratch**
Understand how algorithms work at a fundamental level - not just calling library functions
**2. Select the Right Algorithm**
Know when to use linear regression vs. random forest vs. neural networks
**3. Handle Real-World Data**
Clean messy data, engineer features, handle missing values and outliers
**4. Evaluate Models Properly**
Go beyond accuracy to precision, recall, AUC, and business metrics
**5. Deploy to Production**
Build APIs, monitor models, and handle the full ML lifecycle
**6. Communicate Results**
Explain model decisions to non-technical stakeholders
***
## ๐ผ Career Impact: What ML Engineers Earn
> **Industry Salary Data (2024-2025)**
>
> | Role | Experience | US Salary Range | Key Skills From This Course |
> | - | - | - | - |
> | **Junior ML Engineer** | 0-2 years | $90K - $130K | Modules 1-10 (Fundamentals) |
> | **ML Engineer** | 2-5 years | $130K - $180K | Modules 11-19 (Advanced) |
> | **Senior ML Engineer** | 5+ years | $180K - $250K | Full course + specialization |
> | **ML Lead/Manager** | 7+ years | $200K - $300K | Course + leadership skills |
> | **Research Scientist** | PhD + exp | $180K - $350K | Deep math + research skills |
>
> **Top Companies Hiring ML Engineers:**
>
> * **FAANG**: Google, Meta, Amazon, Apple, Netflix
> * **AI-First**: OpenAI, Anthropic, DeepMind, Cohere
> * **Finance**: Citadel, Two Sigma, Jane Street, Goldman
> * **Startups**: Thousands of well-funded AI startups
>
> **This course prepares you for roles like:**
>
> * Machine Learning Engineer
> * Data Scientist
> * Applied Scientist
> * ML Platform Engineer
> * AI/ML Product Manager (technical)
***
## ๐ Success Stories: What Learners Build
> **Customer Churn Predictor**
>
> A model that identifies at-risk customers 2 weeks before they leave, saving a SaaS company \$2M/year in retention costs.
> **Fraud Detection System**
>
> Real-time fraud detection catching 94% of fraudulent transactions while only flagging 0.1% false positives.
> **Demand Forecasting**
>
> Inventory prediction reducing overstock by 30% for an e-commerce company.
> **Content Recommendation**
>
> A recommendation engine increasing user engagement by 40% for a media platform.
***
## Your Learning Path
### Part 1: The Foundation (This Is Not Scary)
> **[Module 1: The Prediction Game](https://resources.devweekends.com/courses/ml-mastery/01-prediction-game.md)**
>
> Start with a simple question: can we predict house prices? Build your first model with just arithmetic.
> **[Module 2: Learning From Mistakes](https://resources.devweekends.com/courses/ml-mastery/02-learning-from-mistakes.md)**
>
> How do we measure "wrong"? How do we get "less wrong"? The core ideas that power all of ML.
> **[Module 3: Linear Regression](https://resources.devweekends.com/courses/ml-mastery/03-linear-regression.md)**
>
> Your first "real" ML algorithm. Spoiler: it's just fitting a line through points.
> **[Module 4: Classification](https://resources.devweekends.com/courses/ml-mastery/04-classification.md)**
>
> What if the answer isn't a number but a category? Spam or not spam? Cat or dog?
### Part 2: Core Algorithms
> **[Module 4a: K-Nearest Neighbors](https://resources.devweekends.com/courses/ml-mastery/04a-knn.md)**
>
> The simplest idea: find similar examples and use their answers. Intuitive yet powerful.
> **[Module 5: Decision Trees](https://resources.devweekends.com/courses/ml-mastery/05-decision-trees.md)**
>
> How would YOU make decisions? ML trees do the same thing, just faster.
> **[Module 5a: Support Vector Machines](https://resources.devweekends.com/courses/ml-mastery/05a-svm.md)**
>
> Find the perfect boundary between classes with maximum margin.
> **[Module 5b: Naive Bayes](https://resources.devweekends.com/courses/ml-mastery/05b-naive-bayes.md)**
>
> Probabilistic classification - surprisingly powerful for text data.
> **[Module 6: Ensemble Methods](https://resources.devweekends.com/courses/ml-mastery/06-ensemble-methods.md)**
>
> What if we asked 100 models and took a vote? Random Forests and Gradient Boosting.
> **[Module 7: Model Evaluation](https://resources.devweekends.com/courses/ml-mastery/07-model-evaluation.md)**
>
> How do you know if your model is actually good? Metrics beyond accuracy.
### Part 3: Professional Skills
> **[Module 8: Feature Engineering](https://resources.devweekends.com/courses/ml-mastery/08-feature-engineering.md)**
>
> The secret weapon. 80% of the magic is in data preparation.
> **[Module 9: Hyperparameter Tuning](https://resources.devweekends.com/courses/ml-mastery/09-hyperparameter-tuning.md)**
>
> Find the best settings for any model automatically.
> **[Module 10: End-to-End Project](https://resources.devweekends.com/courses/ml-mastery/10-end-to-end-project.md)**
>
> Build a complete ML project from start to finish.
> **[Module 11: Clustering](https://resources.devweekends.com/courses/ml-mastery/11-clustering.md)**
>
> Unsupervised learning: find groups when you don't have labels.
### Part 4: Advanced Topics
> **[Module 12: Neural Networks](https://resources.devweekends.com/courses/ml-mastery/12-neural-networks.md)**
>
> From biology to code: understand how deep learning works.
> **[Module 13: Regularization](https://resources.devweekends.com/courses/ml-mastery/13-regularization.md)**
>
> Fight overfitting with L1, L2, dropout, and more.
> **[Module 14: Model Deployment](https://resources.devweekends.com/courses/ml-mastery/14-model-deployment.md)**
>
> Take your model from notebook to production API.
> **[Module 15: Time Series](https://resources.devweekends.com/courses/ml-mastery/15-time-series.md)**
>
> Predict the future from sequential data - trends, seasonality, forecasting.
### Part 5: Theory & Best Practices
> **[Module 16: Bias-Variance Tradeoff](https://resources.devweekends.com/courses/ml-mastery/16-bias-variance.md)**
>
> The fundamental tradeoff that governs all machine learning.
> **[Module 17: Data Leakage](https://resources.devweekends.com/courses/ml-mastery/17-data-leakage.md)**
>
> The silent killer of ML models in production - learn to avoid it.
> **[Module 18: Dimensionality Reduction](https://resources.devweekends.com/courses/ml-mastery/18-dimensionality-reduction.md)**
>
> PCA, t-SNE, UMAP - handle high-dimensional data effectively.
> **[Module 19: Capstone Project](https://resources.devweekends.com/courses/ml-mastery/19-capstone-project.md)**
>
> Build a complete ML system from problem definition to production.
### Part 6: Real-World Challenges
> **[Module 20: Imbalanced Data](https://resources.devweekends.com/courses/ml-mastery/20-imbalanced-data.md)**
>
> When 99% of data is one class - SMOTE, class weights, and resampling.
> **[Module 21: Model Explainability](https://resources.devweekends.com/courses/ml-mastery/21-explainability.md)**
>
> SHAP, LIME, feature importance - understand why models decide.
> **[Module 22: ML Pipelines](https://resources.devweekends.com/courses/ml-mastery/22-ml-pipelines.md)**
>
> Build reproducible, production-ready workflows with sklearn pipelines.
> **[Module 23: Common Mistakes](https://resources.devweekends.com/courses/ml-mastery/23-common-mistakes.md)**
>
> Avoid the pitfalls that trip up even experienced practitioners.
***
## Math Prerequisites: We've Got You Covered
This course links to our math courses when needed. Don't worry - we explain the intuition first, then link to the math if you want to go deeper.
> **[Linear Algebra](https://resources.devweekends.com/courses/math-for-ml-linear-algebra/01-introduction.md)**
>
> Vectors, matrices, similarity measures - the language of data.
> **[Calculus](https://resources.devweekends.com/courses/math-for-ml-calculus/00-introduction.md)**
>
> Derivatives and gradients - how models learn.
> **[Statistics](https://resources.devweekends.com/courses/statistics-for-ml/01-introduction.md)**
>
> Probability and inference - understanding uncertainty.
***
## ๐ฏ Model Selection: When to Use What
**One of the biggest challenges in ML is choosing the right model.** Here's your decision framework:
> **Quick Model Selection Guide**
>
> ### By Problem Type:
>
> | Your Problem | First Try | If It's Not Enough | Advanced Option |
> | - | - | - | - |
> | **Predict a number** (house prices) | Linear Regression | Random Forest Regressor | Gradient Boosting (XGBoost) |
> | **Predict a category** (spam/not spam) | Logistic Regression | Random Forest Classifier | Gradient Boosting or Neural Net |
> | **Group similar items** (customer segments) | K-Means | Hierarchical Clustering | DBSCAN for weird shapes |
> | **Find patterns in sequences** (stock prices) | ARIMA | Prophet | LSTM Neural Network |
> | **Images** (cat vs dog) | CNN (pretrained) | Fine-tune ResNet | Custom architecture |
> | **Text** (sentiment analysis) | Naive Bayes | BERT embeddings + Logistic | Fine-tune transformer |
>
> ### By Dataset Size:
>
> | Dataset Size | Best Approaches | Why |
> | - | - | - |
> | **\< 1,000 rows** | Simple models (Linear, Naive Bayes) | Not enough data for complex models to generalize -- they'll memorize instead of learn |
> | **1,000-100,000 rows** | Tree ensembles (Random Forest, XGBoost) | Sweet spot for most algorithms; enough signal without needing GPU infrastructure |
> | **> 100,000 rows** | Deep learning becomes viable | Enough data to learn complex patterns; XGBoost still often wins on tabular data |
> | **Millions of rows** | Neural networks, XGBoost with sampling | Can exploit complex patterns, but watch for training time and diminishing returns |
>
> ### By Interpretability Need:
>
> | Need to Explain Predictions? | Use These | Avoid These |
> | - | - | - |
> | **Yes (healthcare, finance)** | Linear models, Decision Trees, Rule-based | Deep neural nets, Ensemble methods |
> | **Somewhat (business reporting)** | Tree ensembles + SHAP | Black-box deep learning |
> | **No (internal optimization)** | Anything that works! | N/A |
> **Model Tradeoffs Cheat Sheet**
>
> ### Understanding the Tradeoffs:
>
> | Model | Accuracy | Speed | Interpretability | Handles Missing Data | Needs Feature Scaling |
> | - | - | - | - | - | - |
> | **Linear Regression** | โ
โ
โ | โ
โ
โ
| โ
โ
โ
| No | Yes |
> | **Logistic Regression** | โ
โ
โ | โ
โ
โ
| โ
โ
โ
| No | Yes |
> | **Decision Tree** | โ
โ
โ | โ
โ
โ
| โ
โ
โ
| Yes | No |
> | **Random Forest** | โ
โ
โ
| โ
โ
โ | โ
โโ | Yes | No |
> | **XGBoost** | โ
โ
โ
| โ
โ
โ | โ
โโ | Yes | No |
> | **SVM** | โ
โ
โ
| โ
โโ | โ
โโ | No | Yes |
> | **KNN** | โ
โ
โ | โ
โโ | โ
โ
โ | No | Yes |
> | **Neural Network** | โ
โ
โ
| โ
โโ | โ
โโ | No | Yes |
> | **Naive Bayes** | โ
โ
โ | โ
โ
โ
| โ
โ
โ
| Yes | No |
>
> ### Common Mistakes to Avoid:
>
> | Mistake | Why It's Bad | What to Do Instead |
> | - | - | - |
> | Starting with neural nets | Overkill for tabular data, hard to debug | Start with Random Forest/XGBoost -- they're the workhorse of Kaggle competitions for a reason |
> | Ignoring baselines | Can't tell if your model is actually good | Always compare to simple models; a "predict the mean" baseline catches embarrassing surprises |
> | Tuning before feature engineering | Features matter more than hyperparameters | Get features right first -- a great feature beats a perfectly tuned model every time |
> | Using accuracy for imbalanced data | 99% accuracy if you always predict majority | Use precision, recall, F1, AUC -- see Module 7 for the full breakdown |
> | Not looking at your data first | You'll build models on garbage | Always do EDA -- plot distributions, check for nulls, look at correlations before touching sklearn |
***
## The Philosophy: Math As Needed
We don't front-load math. Instead:
1. **You encounter a problem** (Why isn't my prediction getting better?)
2. **We show the intuition** (You need to find the "slope" that minimizes error)
3. **We link to the math** (That's what [derivatives](https://resources.devweekends.com/courses/math-for-ml-calculus/01-derivatives.md) do!)
4. **You understand why it matters**
This way, you never wonder "why am I learning this?" โ you know exactly why.
***
## ๐งน Real-World Data: It's Never Clean
Textbook ML examples use clean, perfect datasets. Reality is different:
> **Messy Data Problems We'll Tackle**
>
> | Real-World Problem | Where We Cover It | What You'll Learn |
> | - | - | - |
> | **Missing values** | Module 8, 10 | Imputation strategies, when to drop vs fill |
> | **Outliers** | Module 8, 7 | Detection methods, robust models |
> | **Imbalanced classes** | Module 20 | SMOTE, class weights, threshold tuning |
> | **Feature types mixed** | Module 8 | Encoding categoricals, handling text + numbers |
> | **Data leakage** | Module 17 | The silent killer of models in production |
> | **Distribution shift** | Module 14, 23 | When training โ production data |
> | **Noisy labels** | Module 7, 23 | Dealing with human labeling errors |
>
> **Our approach**: Every end-to-end project uses *real* messy datasets. You'll learn to:
>
> 1. **Diagnose** data quality issues before modeling
> 2. **Clean** appropriately without destroying information
> 3. **Validate** that your cleaning didn't introduce bias
> 4. **Document** your decisions for reproducibility
> [!NOTE]
>
> **๐ Math-to-ML Connection**: Throughout this course, you'll see explicit callouts like this showing how math concepts power ML algorithms:
>
> | Math Concept | ML Application |
> | - | - |
> | **Dot product** | Similarity in KNN, attention in transformers |
> | **Matrix multiplication** | Every neural network layer |
> | **Gradient** | How any model learns (backpropagation) |
> | **Probability distributions** | Loss functions, Naive Bayes, uncertainty |
> | **Eigenvalues** | PCA for dimensionality reduction |
>
> Look for the ๐ symbol to see these connections!
***
## What You'll Build
By the end of this course, you'll have built:
| Project | What It Does | Skills Practiced |
| - | - | - |
| **House Price Predictor** | Estimate prices for any house | Linear regression, feature engineering |
| **Email Spam Detector** | Filter spam automatically | Classification, Naive Bayes, thresholds |
| **Movie Recommender** | Suggest similar movies | KNN, distance metrics, similarity |
| **Customer Churn Predictor** | Identify who might leave | End-to-end pipeline, business impact |
| **Customer Segments** | Group similar customers | Clustering, unsupervised learning |
| **Stock Forecaster** | Predict time series trends | ARIMA, Prophet, feature engineering |
| **Digit Recognizer** | Classify handwritten digits | Neural networks, deep learning intro |
| **Production API** | Deploy and monitor a model | FastAPI, Docker, monitoring |
| **Full Capstone** | Complete churn system | Problem to production pipeline |
***
## ๐ฎ Interactive Learning Tools
> **[Scikit-Learn Playground](https://scikit-learn.org/stable/auto_examples/index.html)**
>
> Interactive examples for every algorithm we cover. Run code directly in your browser.
> **[TensorFlow Playground](https://playground.tensorflow.org/)**
>
> Visualize neural networks learning in real-time. Adjust layers, neurons, and watch decision boundaries form.
> **[Kaggle Notebooks](https://www.kaggle.com/code)**
>
> Free GPU-enabled notebooks with datasets. Perfect for practicing after each module.
> **[MLflow Tracking](https://mlflow.org/)**
>
> Track experiments like a pro. We'll use this in Modules 14+.
***
## ๐ Course Roadmap: Your 8-Week Journey
> **Recommended Learning Schedule**
>
> ### Week 1-2: Foundation (Modules 1-4)
>
> **Goal**: Understand what ML is and build your first models
>
> | Day | Module | Time | Outcome |
> | - | - | - | - |
> | 1-2 | Module 1: Prediction Game | 3h | Build model from scratch, no libraries |
> | 3-4 | Module 2: Learning From Mistakes | 3h | Understand loss functions, gradient descent |
> | 5-6 | Module 3: Linear Regression | 4h | Complete regression with scikit-learn |
> | 7-8 | Module 4: Classification | 4h | Logistic regression, spam detector |
>
> ### Week 3-4: Core Algorithms (Modules 4a-7)
>
> **Goal**: Master the fundamental ML algorithms
>
> | Day | Module | Time | Outcome |
> | - | - | - | - |
> | 9-10 | Module 4a-5: KNN & Trees | 4h | Two intuitive classifiers |
> | 11-12 | Module 5a-5b: SVM & Naive Bayes | 4h | Two more powerful classifiers |
> | 13-14 | Module 6: Ensemble Methods | 4h | Random Forest, Gradient Boosting |
> | 15-16 | Module 7: Model Evaluation | 4h | Metrics, cross-validation, comparison |
>
> ### Week 5-6: Professional Skills (Modules 8-14)
>
> **Goal**: Learn real-world ML practices
>
> | Day | Module | Time | Outcome |
> | - | - | - | - |
> | 17-18 | Module 8: Feature Engineering | 4h | Transform raw data to features |
> | 19-20 | Module 9-10: Tuning & End-to-End | 6h | Complete ML project |
> | 21-22 | Module 11-12: Clustering & NNs | 5h | Unsupervised + deep learning intro |
> | 23-24 | Module 13-14: Regularization & Deployment | 5h | Production-ready models |
>
> ### Week 7-8: Advanced & Capstone (Modules 15-26)
>
> **Goal**: Handle real-world challenges, build portfolio project
>
> | Day | Module | Time | Outcome |
> | - | - | - | - |
> | 25-26 | Modules 15-17: Time Series, Bias-Variance, Leakage | 5h | Advanced concepts |
> | 27-28 | Modules 18-21: PCA, Imbalanced, Explainability | 5h | Real-world challenges |
> | 29-30 | Modules 22-23: Pipelines, Common Mistakes | 4h | Best practices |
> | 31-32 | Module 19: Capstone Project | 8h | Complete portfolio piece |
>
> **Total: \~60 hours over 8 weeks (7-8 hours/week)**
***
## โก Quick Start: Environment Setup
```bash theme={null}
# Create a virtual environment
python -m venv ml-mastery-env
# Activate it (Windows)
ml-mastery-env\\Scripts\\activate
# Activate it (Mac/Linux)
source ml-mastery-env/bin/activate
# Install dependencies
pip install numpy pandas matplotlib seaborn scikit-learn jupyter
pip install xgboost lightgbm catboost # Gradient boosting
pip install plotly ipywidgets # Interactive visualizations
pip install mlflow # Experiment tracking
# Start Jupyter
jupyter notebook
```
> [!TIP]
>
> **Pro Tip**: Use Google Colab if you don't want to set up locally. It's free, has GPU support, and all libraries pre-installed!
***
## Prerequisites Check
You're ready if you can:
```python theme={null}
# 1. Write a function
def calculate_average(numbers):
total = 0
for num in numbers:
total += num
return total / len(numbers)
# 2. Work with lists
prices = [250000, 300000, 450000]
print(calculate_average(prices)) # 333333.33
# 3. Use basic conditionals
if price > 400000:
print("Expensive!")
```
If that looks familiar, you're good to go.
> **๐งช Diagnostic Quiz: Test Your Readiness**
>
> **Answer these questions to gauge your preparation:**
>
> **1. Python Basics**
>
> ```python theme={null}
> data = [3, 1, 4, 1, 5, 9, 2, 6]
> result = [x * 2 for x in data if x > 3]
> print(result)
> ```
>
>
> What does this print?
> `[8, 10, 18, 12]` - It doubles numbers greater than 3. If you got this, your Python is ready!
>
>
> **2. Math Intuition**
> If a house with 2000 sq ft costs $400,000, and a house with 3000 sq ft costs $500,000, what might a 2500 sq ft house cost?
>
>
> Answer
> Around \$450,000 (linear interpolation). If you reasoned this way, you already have ML intuition!
>
>
> **3. Data Thinking**
> You have 1000 emails labeled spam/not-spam. 950 are not spam, 50 are spam. A model that always predicts "not spam" gets 95% accuracy. Is this model good?
>
>
> Answer
> No! It catches 0% of actual spam. You need to look at precision/recall for imbalanced data. We cover this in Module 7.
>
>
> **Remediation Paths:**
>
> | If you struggled with... | Do this first |
> | - | - |
> | Python syntax | [Python Crash Course](https://resources.devweekends.com/courses/python-crash-course) |
> | List operations | Python Crash Course - Lists section |
> | Math intuition | Proceed! We'll teach what you need |
***
## Ready?
> **[Start Module 1: The Prediction Game](https://resources.devweekends.com/courses/ml-mastery/01-prediction-game.md)**
>
> Let's predict some house prices. No libraries, no frameworks, just logic and arithmetic.
***
## ๐ Additional Resources
> **Books, Courses, and Communities**
>
> **Books (Free Online)**
>
> * *Hands-On ML with Scikit-Learn & TensorFlow* by Aurรฉlien Gรฉron - The practical bible
> * *The Hundred-Page ML Book* by Andriy Burkov - Concise theory
> * *Pattern Recognition and ML* by Bishop - Deep theory (advanced)
>
> **Practice Platforms**
>
> * **Kaggle**: Competitions, datasets, notebooks (kaggle.com)
> * **HuggingFace**: Models, datasets, demos (huggingface.co)
> * **Papers With Code**: Research with implementation (paperswithcode.com)
>
> **Communities**
>
> * **r/MachineLearning**: Research and news
> * **r/learnmachinelearning**: Beginner-friendly
> * **ML Discord servers**: Real-time help
> * **Local ML Meetups**: Networking
>
> **YouTube Channels**
>
> * **StatQuest**: Best visual explanations
> * **3Blue1Brown**: Math intuition
> * **Yannic Kilcher**: Paper reviews
> * **Two Minute Papers**: Latest research
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.