Zero to LLMs

Free course · 85 episodes · 6 phases

Zero to LLMs

Machine Learning, Deep Learning & Transformers for absolute beginners. Start from your first line of Python and finish by fine-tuning your own language model.

Start with Episode 1
Phase 0

Absolute Foundations

1–3 weeks · Python, NumPy, Pandas, plotting and the intuitive math every later phase depends on.

  1. 01Course Intro & Setting Up Google ColabWhat ML, DL and LLMs are, how this course is organised, and running your first line of Python in Colab.
  2. 02Python Basics: Variables & Data TypesStoring values in variables and the core types: int, float, str, bool.Soon
  3. 03Lists & TuplesOrdered collections: creating, indexing, slicing and modifying lists.Soon
  4. 04Dictionaries & SetsKey-value data and unique collections — the shape of most real data.Soon
  5. 05Conditions & LoopsMaking decisions with if/else and repeating work with for and while.Soon
  6. 06FunctionsPackaging code into reusable functions with parameters and return values.Soon
  7. 07Classes & ObjectsObject-oriented basics — the pattern PyTorch models are built on.Soon
  8. 08Files, Modules & pipReading and writing files, importing modules and installing packages.Soon
  9. 09NumPy Part 1: Arrays, Shapes & IndexingThe array — the data structure behind every ML library.Soon
  10. 10NumPy Part 2: Broadcasting & Linear AlgebraVectorised maths without loops, and the linear algebra operations ML uses.Soon
  11. 11Pandas Part 1: DataFramesLoading a CSV and selecting, filtering and sorting tabular data.Soon
  12. 12Pandas Part 2: groupby, merge & Missing DataSummarising, combining and cleaning tables.Soon
  13. 13Plotting with Matplotlib & SeabornTurning data into charts you can actually read.Soon
  14. 14Math 1: Vectors, Matrices & Dot ProductsLinear algebra intuition with pictures and NumPy — no heavy proofs.Soon
  15. 15Math 2: Probability & StatisticsDescribing data and uncertainty: mean, variance and distributions.Soon
  16. 16Math 3: Bayes' RuleUpdating beliefs with evidence — the medical-test example, step by step.Soon
  17. 17Math 4: Derivatives, Gradients & Gradient DescentWhy learning needs slopes, and gradient descent by hand in Python.Soon
Phase 1

Classical Machine Learning & Data Science Projects

4–8 weeks · EDA, scikit-learn, Random Forests and full end-to-end projects.

  1. 18What Is Machine Learning?Supervised vs unsupervised learning and the standard ML workflow.Soon
  2. 19EDA Part 1: Missing Values & OutliersFirst look at a real dataset and cleaning what's broken.Soon
  3. 20EDA Part 2: Distributions & CorrelationUnivariate and bivariate analysis to find what matters.Soon
  4. 21Feature Engineering: Encoding & ScalingTurning raw columns into features models can use.Soon
  5. 22Train/Test Split & Cross-ValidationMeasuring how well a model generalises to unseen data.Soon
  6. 23Linear RegressionFitting a line, what the coefficients mean, and the loss being minimised.Soon
  7. 24Logistic RegressionClassification with the sigmoid function and probabilities.Soon
  8. 25Classification MetricsWhy accuracy lies, and what to use instead.Soon
  9. 26Regression Metrics & the Bias–Variance TradeoffDiagnosing underfitting and overfitting.Soon
  10. 27Decision TreesHow a tree asks questions to split data, and why a single tree overfits.Soon
  11. 28Random ForestsWhy many trees beat one: bagging, feature importance and OOB score.Soon
  12. 29Gradient Boosting: XGBoost & LightGBMTrees that fix each other's mistakes — the tabular data champion.Soon
  13. 30KNN & SVM IntuitionTwo classic models: nearest neighbours and maximum-margin boundaries.Soon
  14. 31Hyperparameter TuningFinding good settings with GridSearchCV and RandomizedSearchCV.Soon
  15. 32Unsupervised Learning: K-Means ClusteringGrouping data without labels.Soon
  16. 33PCA: Dimensionality ReductionCompressing many features into a few that keep most of the information.Soon
  17. 34scikit-learn PipelinesClean, leak-free preprocessing + model in one object.Soon
  18. 35Project 1: Titanic Survival PredictionA full classification project from EDA to Kaggle submission.Soon
  19. 36Project 2: House Price PredictionA full regression project with feature engineering and boosting.Soon
  20. 37Project 3: Your Own Dataset, End to EndPicking a dataset, framing the problem and explaining the results.Soon
  21. 38Deploy Your Model with StreamlitTurning a trained model into a web app anyone can use.Soon
Phase 2

Deep Learning Fundamentals

6–10 weeks · Neural networks from scratch, then in Keras and PyTorch, plus CNNs.

  1. 39From ML to Deep Learning: The PerceptronThe single artificial neuron and what it can and can't learn.Soon
  2. 40Multi-Layer Perceptrons & Activation FunctionsStacking neurons into layers, and why non-linearity matters.Soon
  3. 41Loss FunctionsHow a network measures how wrong it is.Soon
  4. 42Gradient Descent & OptimizersSGD, mini-batches, momentum and Adam.Soon
  5. 43Backpropagation IntuitionThe chain rule, step by step, on a tiny network.Soon
  6. 44Build a Neural Network from Scratch in NumPyEvery line of a working network, no frameworks.Soon
  7. 45Keras Sequential API: Handwritten Digits (MNIST)Your first real deep learning model in a few lines.Soon
  8. 46Keras Functional APIBuilding models with multiple inputs, outputs and branches.Soon
  9. 47PyTorch: Tensors & AutogradPyTorch's building blocks and automatic differentiation.Soon
  10. 48PyTorch: nn.Module, Dataset & DataLoaderDefining models and feeding data the PyTorch way.Soon
  11. 49Writing the Training Loop Yourself (Fashion-MNIST)The loop every PyTorch project uses, written line by line.Soon
  12. 50Fighting Overfitting: Dropout, BatchNorm & RegularizationTechniques that help networks generalise.Soon
  13. 51CNNs: Convolutions & PoolingHow networks see images, filter by filter.Soon
  14. 52Build a CNN on CIFAR-10 (+ Transfer Learning)A real image classifier, then a pretrained model for comparison.Soon
Phase 3

Sequence Models: RNN, LSTM & Beyond

4–6 weeks · The bridge to language models: recurrence, memory and text processing.

  1. 53Why Sequences Are Special: RNNsOrder matters — how recurrent networks carry a hidden state.Soon
  2. 54Vanishing & Exploding GradientsWhy plain RNNs forget, shown numerically.Soon
  3. 55LSTM & GRU ExplainedGates and cell state: how LSTMs remember long dependencies.Soon
  4. 56Text Prep: Tokenization, Padding & EmbeddingsTurning words into numbers a network can learn from.Soon
  5. 57Sentiment Analysis with an LSTMClassifying movie reviews as positive or negative.Soon
  6. 58Time-Series Forecasting with an LSTMPredicting the next values in a sequence.Soon
  7. 59Character-Level Text GenerationTraining a model that writes text one character at a time.Soon
  8. 60Sequence-to-Sequence IntroductionMapping one sequence to another, as in translation.Soon
Phase 4

Attention, Encoder-Decoder & Transformers

6–10 weeks · The core of modern LLMs: attention, transformers and how GPT-2 is trained.

  1. 61Encoder-Decoder & the Bottleneck ProblemWhy squeezing a whole sentence into one vector fails on long inputs.Soon
  2. 62Attention: Bahdanau & LuongLetting the decoder look back at every encoder step.Soon
  3. 63Query, Key, Value IntuitionThe search-engine analogy behind all modern attention.Soon
  4. 64Self-Attention from ScratchEvery token attending to every other token, coded in PyTorch.Soon
  5. 65Multi-Head Attention & Positional EncodingsSeveral attention patterns at once, and how order is injected.Soon
  6. 66The Transformer BlockAttention + feed-forward + residuals + layer norm.Soon
  7. 67Three Families: BERT, GPT & T5Encoder-only, decoder-only and encoder-decoder transformers.Soon
  8. 68How GPT-2 Is TrainedNext-token prediction on huge corpora with a decoder-only stack.Soon
  9. 69Build a Tiny GPT from Scratch, Part 1Data, tokenizer and the model architecture.Soon
  10. 70Build a Tiny GPT from Scratch, Part 2Training, learning-rate schedules and generating text.Soon
  11. 71Hugging Face: Pipelines, Tokenizers & ModelsUsing thousands of pretrained models in a few lines.Soon
  12. 72Fine-Tune a Small Pretrained ModelAdapting a pretrained transformer to text classification.Soon
Phase 5

Modern Training, Fine-Tuning & Embedding Models

Ongoing · Working with real-scale models: PEFT, precision, embeddings and scaling.

  1. 73Pre-Training vs Fine-Tuning vs Instruction TuningThe stages that turn raw text into a helpful assistant.Soon
  2. 74Hugging Face Datasets & Trainer Deep DiveLoading, processing and training efficiently at scale.Soon
  3. 75LoRA & Adapters (PEFT)Fine-tuning a fraction of the parameters for a fraction of the cost.Soon
  4. 76QLoRA: Fine-Tune an LLM on Free Colab4-bit quantised base model + LoRA on a free GPU.Soon
  5. 77Precision: FP32, FP16, BF16 & QuantizationHow number formats trade accuracy for speed and memory.Soon
  6. 78Gradient Accumulation & Distributed Training BasicsTraining with bigger effective batches and more GPUs.Soon
  7. 79Experiment Tracking with Weights & BiasesLogging, comparing and reproducing experiments.Soon
  8. 80Embeddings & Contrastive LearningHow embedding models learn that similar things sit close together.Soon
  9. 81Sentence Transformers & Semantic SearchSearching by meaning instead of keywords.Soon
  10. 82Fine-Tune Your Own Embedding ModelAdapting an embedding model to your domain.Soon
  11. 83Scaling Laws & Memory MathHow big models get better, and how much GPU memory they really need.Soon
  12. 84The Big-Model Toolkit: Checkpointing, ZeRO & FlashAttentionAwareness-level tour of the techniques that make billion-parameter training possible.Soon
  13. 85Capstone Project & What's NextPlanning your capstone and how to keep learning after the course.Soon