---
title: "Curriculum overview"
description: "Explore 108 AI research lessons across math, PyTorch, transformers, RL, LLMs, and MLOps. Selected lessons are free; Pro unlocks the full path."
canonical_url: "https://fanout.sh/ai/overview"
md_url: "https://fanout.sh/ai/overview.md"
access: "public"
---

# Curriculum overview

Explore 108 AI research lessons across math, PyTorch, transformers, RL, LLMs, and MLOps. Selected lessons are free; Pro unlocks the full path.

## Math Fundamentals

The mathematical foundations you need for AI research — from functions and derivatives to information theory and SVD.

### Functions

Functions are the foundation of neural networks. A **function** is a mathematical relationship that maps inputs to outputs.

**Linear Function:** f(x) = 2x + 3 — takes any number x and returns 2x + 3.

**Quadratic Function:** f(x) = x² + 2x + 1

**Mathematical Definition:** A function f: A → B maps every element in set A to exactly one element in set B.

**Types of Functions:**
- **Linear Functions** — f(x) = mx + b (slope m, y-intercept b)
- **Polynomial Functions** — f(x) = aₙxⁿ + ... + a₁x + a₀
- **Exponential Functions** — f(x) = aˣ
- **Trigonometric Functions** — used in RoPE (Rotary Positional Embeddings)

**Neural Network Functions:**
- **Sigmoid** — f(x) = 1 / (1 + e^(-x)), squashes to (0,1)
- **ReLU** — f(x) = max(0, x), the most popular activation
- **Tanh** — f(x) = (eˣ - e⁻ˣ) / (eˣ + e⁻ˣ), squashes to (-1,1)

Video: https://www.youtube.com/watch?v=kvGsIo1TmsM

### Derivatives

Derivatives tell you how fast a function is changing at any point.

**Common Derivative Rules:**
- **Power Rule:** d/dx[xⁿ] = nxⁿ⁻¹
- **Constant Multiple:** d/dx[cf(x)] = c·f'(x)
- **Sum Rule:** d/dx[f(x) + g(x)] = f'(x) + g'(x)
- **Product Rule:** d/dx[f(x)·g(x)] = f'(x)·g(x) + f(x)·g'(x)
- **Chain Rule:** d/dx[f(g(x))] = f'(g(x))·g'(x)

**Partial Derivatives:** When a function has multiple inputs (like neural network weights), we take the derivative with respect to one variable while holding others constant.

Key for neural networks: derivatives power backpropagation.

Video: https://www.youtube.com/watch?v=9vKqVkMQHKk

### Vectors

Vectors are ordered lists of numbers representing magnitude and direction.

**Key Operations:**
- **Addition:** [a₁, a₂] + [b₁, b₂] = [a₁+b₁, a₂+b₂]
- **Scalar Multiplication:** c·[a₁, a₂] = [ca₁, ca₂]
- **Dot Product:** a·b = a₁b₁ + a₂b₂ (measures similarity)
- **Magnitude:** ||v|| = √(v₁² + v₂² + ...)

In neural networks, inputs, weights, and embeddings are all vectors. In LLMs, word embeddings are high-dimensional vectors where similar words have similar vectors.

Video: https://www.youtube.com/watch?v=fNk_zzaMoSs

### Gradients

The gradient generalizes derivatives to multiple dimensions. It's a vector pointing in the direction of steepest increase.

**What the Gradient Tells Us:**
- **Direction:** Which way to go to increase the function fastest
- **Magnitude:** How steep the slope is

**Gradient Descent:** The core of machine learning training. We move in the opposite direction of the gradient to minimize the loss function. The gradient tells us exactly how to update each weight to reduce error.

Video: https://www.youtube.com/watch?v=vp2oUoBDH4w

### Matrices

A matrix is a 2D array of numbers. Neural networks are essentially chains of matrix operations.

**Key Operations:**
- **Addition/Subtraction** — element-wise, same shapes required
- **Scalar Multiplication** — multiply every element
- **Matrix Multiplication** — (m×n) @ (n×p) = (m×p), inner dimensions must match
- **Transpose** — flip rows and columns, Aᵀ
- **Determinant** — scalar value, det(A) = 0 means non-invertible
- **Inverse** — A⁻¹ such that A·A⁻¹ = I

**Special Matrices:** Identity (I), Diagonal, Symmetric, Orthogonal.

Video: https://www.youtube.com/watch?v=5H4crNlLK_A

### Hadamard Product (Element-wise Op)

The Hadamard Product is simply element-wise multiplication.

**Why it's the "King" of Efficiency:** Element-wise operations are much faster than matrix multiplication. The Jacobian of an element-wise operation is diagonal, making backprop through it very efficient.

**In Python:** Use `*` for element-wise, `@` for matrix multiplication.

Video: https://www.youtube.com/watch?v=_MaVzNUjMPk

### Moving Averages (EMA)

Dealing with noise in training signals.

**Simple Moving Average (SMA):** Average of last N values. Problem: requires storing N values.

**Exponential Moving Average (EMA):** v_t = β·v_{t-1} + (1-β)·x_t — recursive, memory-efficient.

**Why This Matters for Adam Optimizer:**
- **Momentum** = EMA of Gradients (first moment)
- **RMSProp** = EMA of Squared Gradients (second moment)
- Adam combines both for adaptive learning rates per parameter.

Video: https://www.youtube.com/watch?v=lAq96T8FkTw

## PyTorch Fundamentals

Master the tensor operations that are the building blocks of every neural network implementation.

### 7 PyTorch Tasks (Advanced)

Advanced PyTorch challenges to test and solidify your understanding of tensor operations.

Video: https://www.youtube.com/watch?v=QtlDV2r1ryE

## Reinforcement Learning

How agents learn from interaction — from basic environments to PPO and modern LLM reasoning techniques.

### PPO, LLM Reasoning, Importance Ratio, Advantage

Proximal Policy Optimization — the algorithm behind RLHF for LLMs. Uses importance ratio and clipping to make stable policy updates.

Video: https://www.youtube.com/watch?v=TjHH_--7l8g

### Qwen 3 GSPO & DeepSeek GRPO — LLM Reasoning

Modern approaches to improving LLM reasoning through reinforcement learning — Group Relative Policy Optimization and related techniques.

Video: https://www.youtube.com/watch?v=L94MdLdP21s

## LLM From Scratch

Build state-of-the-art large language models from scratch — LLaMA 4, DeepSeek V3, Qwen 3, and more.

### Llama 4 From Scratch

Building Meta's LLaMA 4 architecture from scratch — understanding the design choices behind one of the most influential open-source LLMs.

Video: https://www.youtube.com/watch?v=yXbF-1n9wxs

## Write Research Paper

The complete workflow from coding experiments to writing and publishing an AI research paper.

### Code, Write & Publish AI Research Paper

**The Complete Pipeline:**
1. Code LLM from scratch
2. Code experiments (Muon vs Adam optimizer comparison)
3. Write the paper

**Skills Covered:**
- **LLM Architecture:** MoE with expert layers, top-k routing, auxiliary loss, RoPE, multi-head attention
- **Optimization:** Implement Muon optimizer, benchmark against Adam
- **ML Engineering:** Structure projects, pipelines, trainers, run cloud experiments
- **Research:** Design experiments, turn results into a publishable paper

**Paper:** github.com/vukrosic/noptims

Video: https://www.youtube.com/watch?v=O2yAMJu8LpI

## Machine Learning Operations (MLOps)

Deploy and maintain ML models in production — from Git and Docker to Kubernetes, CI/CD, and monitoring with Prometheus & Grafana.

### ML Pipeline with DVC & AWS S3

End-to-end NLP Spam Detection pipeline with MLOps best practices.

**Pipeline Stages:** Data Ingestion → Data Validation → Pre-processing → Model Training & Evaluation

**Key Properties:**
- **Modularity:** Each stage is independent — robust and maintainable
- **Data Versioning:** DVC tracks data/model versions with code-level rigor
- **Cloud Integration:** AWS S3 as DVC Remote for heavy datasets and models
- **Reproducibility:** Defined via dvc.yaml for automatic pipeline execution

**Infrastructure:** IAM User & S3 for secure storage, `dvc stage add` with dependencies (-d) and outputs (-o).

Video: https://www.youtube.com/watch?v=oYIBwbHM_PI

## Bonus Lessons

Advanced topics — training dynamics, activation functions, and cutting-edge reasoning architectures.

### Train LLM — Sequence Length vs Batch Size

Exploring the trade-offs between batch size and sequence length when training LLMs.

**Experiment Setup:** Ablation study comparing different batch size × sequence length configurations while keeping total tokens constant.

**Key Components:**
- Experiment configuration with ablation matrix
- Hybrid Optimizer (Muon + AdamW)
- Mixed-precision training with GradScaler
- Gradient accumulation for large effective batch sizes

Video: https://www.youtube.com/watch?v=bu5dhaLmr7E

### SwiGLU — Better Neural Networks

SwiGLU activation function — a gated variant of Swish that has become the standard activation in modern LLMs like LLaMA, PaLM, and Mistral. Outperforms ReLU and GELU in practice.

Video: https://www.youtube.com/watch?v=enPFr-WxHgQ

### 100x AI Reasoning — Tiny Recursive Model

**How a 7M parameter model beats 1T models at Sudoku, Mazes, and ARC-AGI.**

**TRM Architecture:** Uses recursive computation with three nested loops:
- **Innermost Loop (latent recursion):** Phase A (reasoning, updating z) + Phase B (refining answer y)
- **Middle Loop (deep recursion):** 2 warm-up rounds without gradients + 1 final with gradients
- **Outermost Loop:** Up to 16 repetitions with adaptive computation time via learned Q head

The key insight: small models can match or beat massive ones through recursive depth instead of parameter count.

Video: https://www.youtube.com/watch?v=P9zzUM0PrBM

---
This representation contains public Fanout content only. Protected Pro lessons, account data, billing, checkout, and pricing are not included.

Browse the public content map: https://fanout.sh/sitemap.md