Go from Python to production LLMs in one guided path
A genuinely detailed, project-driven curriculum — 26 weeks across 8 phases, each week with its own learning objectives, topic breakdown and hands-on exercise. Start with math and classical machine learning, build up through neural networks and transformers, then fine-tune, prompt, retrieve and orchestrate real large language models — finishing with a deployed AI application.
Prerequisites & tooling
What you should already know
- Basic Python — variables, functions, loops, lists/dicts
- Comfort with high-school-level math (we refresh what's needed)
- No prior machine learning or deep learning experience required
- Python 3.10+ and a code editor installed
Stack you'll work with
From notebooks to a shipped app — the same tools used in industry today.
Your 26-week curriculum
Twenty-six modules, from Python and the math behind ML through classical algorithms and deep learning to transformers, fine-tuning, agents and a deployed capstone LLM application.
Python Data Science Toolchain
Get a reproducible environment and the two libraries every dataset passes through.
- NumPy arrays, broadcasting & vectorization
- Pandas DataFrames, filtering & grouping
- Handling missing data & merging tables
Linear Algebra & Probability for ML
The two mathematical ideas underneath every model from here on.
- Vectors, matrices & matrix multiplication
- Norms, distance & cosine similarity
- Conditional probability & Bayes' theorem
Statistics for Machine Learning
Reason about whether a difference in the numbers is real, or just noise.
- Descriptive statistics: mean, median, variance, percentiles
- Hypothesis testing, p-values & common pitfalls
- Confidence intervals & correlation vs. causation
Data Wrangling & Feature Engineering
Turn a raw, messy dataset into model-ready features with a repeatable pipeline.
- Feature scaling: standardization vs. min-max normalization
- Encoding categorical variables: one-hot, ordinal, target encoding
- Building pipelines with scikit-learn's
Pipeline/ColumnTransformer
The Supervised Learning Workflow
Run a complete supervised-learning experiment, start to finish.
- Train/validation/test splits — why three sets, not two
- The bias–variance tradeoff
- Overfitting & underfitting: causes and fixes
Model Evaluation & Hyperparameter Tuning
Choose the right metric for a problem, and tune without leaking test data.
- Classification metrics: precision, recall, F1, confusion matrix
- Cross-validation strategies (k-fold, stratified)
- Grid search & random search for hyperparameters
Unsupervised Learning & Dimensionality Reduction
Explore unlabeled data and reduce dimensionality without losing signal.
- k-means clustering & choosing k (elbow method, silhouette score)
- PCA: variance explained & choosing components
- t-SNE/UMAP for visualization (conceptual overview)
Classical ML Mini-Project
Independently scope, build and evaluate a full ML solution end to end.
- Framing a real-world problem as an ML task
- Full pipeline: EDA → preprocessing → modeling → evaluation
- Communicating results with metrics, plots & a short write-up
Tree-Based Models & Gradient Boosting
Build, tune and interpret the models behind most tabular ML.
- Decision trees: splits, impurity & overfitting
- Random forests & bagging
- Gradient boosting fundamentals & XGBoost/LightGBM in practice
SVMs, Naive Bayes & Ensemble Methods
Choose among a wider set of classical algorithms based on data shape and assumptions.
- Support vector machines & the kernel trick
- Naive Bayes & its independence assumption
- Bagging vs. boosting vs. stacking
Neural Network Foundations
Explain and implement the mechanics of a neural network from scratch.
- Activation functions: sigmoid, ReLU, softmax
- Backpropagation & the chain rule, by hand
- Gradient descent, learning rate & convergence
Training Deep Networks with PyTorch
Build, train and debug a real neural network with a modern framework.
- PyTorch tensors, autograd & the training loop
- Optimizers: SGD, momentum, Adam
- Regularization: dropout, weight decay, early stopping
Convolutional Neural Networks
Build and train a CNN for image classification.
- Convolutions, kernels, stride & padding
- Classic architectures & a look at ResNet
- Data augmentation & transfer learning with a pretrained CNN
Sequence Models: RNNs, LSTMs & an Intro to Attention
Process ordered data, and see why attention was invented to fix RNNs' limits.
- RNNs & the vanishing gradient problem
- LSTMs & GRUs: gates and why they help
- Attention as a fix: a first, intuitive look
The Attention Mechanism
Implement scaled dot-product and multi-head attention from scratch.
- Queries, keys & values
- Scaled dot-product attention, step by step
- Multi-head attention & why multiple heads help
The Full Transformer Architecture
Assemble a complete transformer block and explain every component's role.
- Positional encoding (sinusoidal & learned)
- Encoder & decoder stacks
- Encoder-only vs. decoder-only vs. encoder-decoder architectures
LLM Pretraining & Tokenization
How raw text becomes training data for a model that can converse and reason.
- Byte-Pair Encoding (BPE) & subword tokenization
- Pretraining objectives: causal LM vs. masked LM
- Context windows & how they constrain a model
Scaling Laws, Model Families & Reading Model Cards
Choose a model using published evidence, not vibes.
- Scaling laws: params, data & compute tradeoffs
- Open-weight vs. closed models
- Reading a model card critically (training data, limitations, intended use)
Fine-Tuning & Transfer Learning
Adapt a pretrained model to a new task via full fine-tuning.
- Transfer learning: freezing vs. fine-tuning layers
- Full fine-tuning workflow for an LLM
- Catastrophic forgetting & how to mitigate it
Parameter-Efficient Tuning & RLHF/DPO
Adapt a large model cheaply, and understand how preference-based training works.
- LoRA: low-rank adapters, explained and implemented
- QLoRA & quantization for memory-efficient tuning
- RLHF (reward models & PPO) and DPO as a simpler alternative
Prompt Engineering & Reasoning
Get reliable, structured behavior out of a model without touching its weights.
- Prompt structure & system/user/assistant roles
- Few-shot prompting & chain-of-thought
- Structured outputs & tool/function schemas
Retrieval-Augmented Generation & Embeddings
Ground model answers in your own data.
- Embeddings & vector similarity (building on Week 2)
- Chunking strategies for long documents
- Vector databases & approximate nearest-neighbor search
Agents, Tool Use & Orchestration
Let a model take actions, not just generate text.
- Function calling & tool-use loops
- The Model Context Protocol (MCP)
- Multi-agent systems, orchestration & agent memory
Evaluation, Safety & Guardrails
Measure whether a model is actually good, safely, before shipping it.
- Building evals & benchmarks for your own use case
- Hallucination detection & mitigation strategies
- Guardrails, content filtering & responsible-AI basics
Deployment, Cost & Latency
Take a model from a notebook to something you can trust and afford in production.
- Serving options: hosted APIs vs. self-hosted inference
- Cost modeling for LLM usage at scale
- Monitoring, rollback & versioning for a deployed LLM app
Capstone: Ship an LLM-Powered Application
Plan, build, evaluate and ship a complete LLM-powered application solo.
- Architecture decisions: RAG vs. fine-tuning vs. prompting, or a combination
- Full implementation, from data to deployment
- Evaluation, safety & cost/latency pass