Map of ML Algorithm Families

Machine learning is far more than supervised classification. This guide covers every major algorithm family — from reinforcement learning to evolutionary computing — with intuitions, trade-offs, and practical pointers for when each shines.

Algorithm Families at a Glance

---

Supervised Learning

The most widely deployed family. You provide labeled training data; the model learns the mapping.

Classification algorithms

Regression algorithms

Most classification algorithms have regression variants: Linear Regression, Ridge/Lasso, Decision Tree Regressor, Random Forest Regressor, Gradient Boosting Regressor, SVR, k-NN Regressor.

Key insight: when to use what

                    Tabular data?
                    /           \
                  Yes            No
                  /                \
         < 100K rows?        Images/Text/Audio?
         /         \              |
       Yes          No           Yes
       /             \            |
  Logistic Reg    XGBoost/     Deep Learning
  Random Forest   LightGBM     (CNN, Transformer)
  (interpretable) (performance)

Gradient boosting (XGBoost, LightGBM, CatBoost) dominates tabular data. Deep learning wins on unstructured data. Don't use neural nets on tabular data unless you've already tried boosting.

---

Unsupervised Learning

No labels. The goal is to discover structure, patterns, or compressed representations.

Clustering

Group similar data points together.

from sklearn.cluster import HDBSCAN
import numpy as np

clusterer = HDBSCAN(min_cluster_size=15, min_samples=5)
labels = clusterer.fit_predict(X)
# labels == -1 means noise/outlier

Dimensionality Reduction

Compress high-dimensional data while preserving structure.

Anomaly Detection

Find data points that don't fit the normal pattern.

---

Self-Supervised Learning

The model creates its own labels from raw data — no manual annotation needed. This is how modern foundation models (LLMs, vision transformers) are pre-trained.

Techniques

Why it matters

Self-supervised pre-training on massive unlabeled data → fine-tune on small labeled dataset. This is the dominant paradigm in modern AI: pre-train once, fine-tune for many tasks.

---

Reinforcement Learning (RL)

An agent learns by interacting with an environment, receiving rewards, and adjusting its policy to maximize cumulative reward.

Core concepts

        ┌───────────────┐
        │  Environment  │
        └───┬───────┬───┘
   state s  │       │  reward r
            ▼       │
        ┌───────────┴───┐
        │     Agent     │
        │   π(a|s)      │──── action a ────►
        └───────────────┘

Algorithm families

Value-based methods

Learn Q(s,a) and pick the action with highest Q.

Policy-based methods

Learn the policy π(a|s) directly.

Model-based methods

Learn a model of the environment and plan within it.

RL applications

Getting started with RL

import gymnasium as gym

# Classic control problem
env = gym.make("CartPole-v1")
obs, info = env.reset()

for _ in range(1000):
    action = env.action_space.sample()  # random policy
    obs, reward, terminated, truncated, info = env.step(action)
    if terminated or truncated:
        obs, info = env.reset()

Key libraries: Gymnasium (environments), Stable-Baselines3 (algorithms), CleanRL (single-file implementations), RLlib (scalable distributed RL), TorchRL (PyTorch-native).

---

Evolutionary & Genetic Algorithms

Inspired by biological evolution: population → fitness evaluation → selection → crossover → mutation → repeat.

Core concepts

Generation 0:  [A] [B] [C] [D] [E]     ← random population
                ↓ evaluate fitness
Fitness:        7   3   9   5   8
                ↓ selection (fittest survive)
Parents:       [A] [C] [E]
                ↓ crossover + mutation
Generation 1:  [AC'] [CE'] [CA'] [EA'] [EC']
                ↓ repeat...

Algorithm variants

When evolutionary beats gradient descent

• Non-differentiable objectives — discrete structures, combinatorial problems
• Multimodal landscapes — many local optima where gradient methods get stuck
• Architecture search — evolving neural network structures (NAS)
• Game AI — evolving strategies for NPCs
• Scheduling/routing — job shop, vehicle routing, timetabling
• Hardware design — circuit optimization, antenna design

Practical example: CMA-ES

import cma

# Minimize a function with CMA-ES
def objective(x):
    return sum((xi - 3)**2 for xi in x)  # minimum at [3, 3, 3, ...]

es = cma.CMAEvolutionStrategy([0] * 10, 0.5)  # 10-dim, initial sigma=0.5
es.optimize(objective)
print(es.result.xbest)  # → close to [3, 3, 3, ...]

Key libraries

---

Probabilistic & Bayesian Methods

Model uncertainty explicitly using probability distributions.

Key approaches

Bayesian Optimization for hyperparameters

from skopt import gp_minimize

def train_and_evaluate(params):
    learning_rate, n_estimators = params
    # Train model, return validation error
    model = XGBClassifier(learning_rate=learning_rate,
                          n_estimators=int(n_estimators))
    model.fit(X_train, y_train)
    return -accuracy_score(y_val, model.predict(X_val))

result = gp_minimize(
    train_and_evaluate,
    [(1e-4, 1.0, "log-uniform"),  # learning_rate
     (50, 500)],                   # n_estimators
    n_calls=50
)

Key libraries

---

Meta-Learning ("Learning to Learn")

Algorithms that improve their learning ability across tasks.

---

Hybrid & Emerging Approaches

Neuro-symbolic AI

Combine neural networks (pattern recognition) with symbolic reasoning (logic, rules).

• Neural Theorem Proving — use neural nets to guide proof search
• Differentiable Programming with Logic — DeepProbLog, Scallop
• LLM + Knowledge Graphs — ground language model outputs in structured knowledge

Graph Neural Networks (GNNs)

Learn on graph-structured data directly.

Applications: molecule property prediction, social network analysis, fraud detection, recommendation systems.

Diffusion Models

Learn to denoise data — the backbone of modern generative AI.

1. Forward process: Gradually add noise to data
2. Reverse process: Neural network learns to remove noise step by step
3. Generation: Start from pure noise, denoise iteratively

Used in: Stable Diffusion, DALL-E 3, Sora (video), protein structure generation.

---

Choosing the Right Family

Resources

• Reinforcement Learning: An Introduction — Sutton & Barto (free online)
• Spinning Up in Deep RL — OpenAI's RL educational resource
• Introduction to Evolutionary Computing — Eiben & Smith
• Probabilistic Machine Learning — Kevin Murphy (free online)
• Dive into Deep Learning — Interactive deep learning textbook
• Papers With Code — State-of-the-art benchmarks across all ML families

:::