Deep Learning with LLM
Build the models, don't just call them. Backpropagation from scratch, CNNs, transformers written by hand, LLM fine-tuning and diffusion pipelines — with the mathematics underneath, not around it.
Four rungs. Start where you are, finish at Mastery.
Sessions are always 2 hours. The hours are fixed; the calendar flexes — the same level runs daily, alternate-day, or as a summer intensive. Prices shown are student prices; professional pricing is on the pricing page.
What deep learning actually is
Watch a neural network learn in front of you, and see plainly where the magic stops and the mathematics starts. A single afternoon, no cost.
Neural-network foundations
Perceptrons to a working multi-layer network you train yourself — activations, loss, gradient descent, and why training goes wrong.
CNNs, RNNs — computer vision and NLP
Convolutional and sequence models applied to real vision and language tasks, with a trained model and honest evaluation to show for it.
Transformers, LLMs and diffusion
Self-attention from scratch, LLM fine-tuning with LoRA, RAG, evals, Stable Diffusion and serving at production scale. Full syllabus below.
What the levels below Mastery cover
Our ladder is a spiral, not a straight line. L0 and L1 are outcome-first: you make something impressive on the first day and no theory gets in the way. L2 is where the foundations genuinely begin. L3 then deliberately re-covers 60–70% of L2 at real depth before going past it — the overlap is a feature, not repetition. You earn the "why" only once you are invested in the "what".
A demo and a guided first build. No theory at all — just a win you can point at.
Bigger builds, same spirit. Concepts appear only where a build actually needs them.
The first real grounding in how and why — taught applied, ending in a project.
Re-covers L2's foundations at full depth, then goes well beyond into advanced work.
"I ran real AI models — today."
See it: A neural net recognizing images, an LLM holding a conversation, and an AI generating images from words.
Make it, guided: Run a pretrained model in a notebook — classify your own photo, generate text and an image, and watch a model "see" and "write".
Runs on Colab with a free GPU — nothing to install. No assessment.
Six sessions, six things you built
- See a model "see" — image classification on your own photos (pretrained)
- Teach a model — train a tiny image classifier, guided
- Language AI — sentiment and summarization with a transformer pipeline
- Generate — make images with a diffusion model via a UI or notebook
- Wrap it — a mini demo app (Gradio) around a model
- Your own mini AI demo, plus a showcase
You leave with a shareable AI demo. Assessed on completion and the showcase.
L2 · Practitioner — 40 hours, where the foundations begin
The first real grounding — how neural networks actually work in PyTorch, CNNs for vision, basic NLP, and applied transformers and LLMs.
| Unit | What you learn and build | Sessions | Hours |
|---|---|---|---|
| U1 · Python & Math Intuition for DL | Tensors, an intuition for gradients, PyTorch basics | 3 | 6 |
| U2 · Neural Networks | Perceptron to MLP, activations, a training loop written in PyTorch | 4 | 8 |
| U3 · Computer Vision with CNNs | Convolutions, image classification, transfer learning | 4 | 8 |
| U4 · NLP & Sequences | Text and embeddings, RNN/LSTM basics, sentiment | 3 | 6 |
| U5 · Using Transformers & LLMs | Hugging Face pipelines, applied transformer and LLM use | 3 | 6 |
| U6 · Practitioner Project | Build and demo a deep-learning model — vision or text | 3 | 6 |
| Total | 20 | 40 |
Project: A working deep-learning model — an image classifier, a text model, or a small generative demo — presented.
Tools: PyTorch · torchvision · Hugging Face · OpenCV · Gradio · Colab GPU · Git.
Assessment: Continuous labs 40% · unit checkpoints 20% · project 40%.
Overlap into L3: U1–U5 are the foundations L3 deepens — it adds DL maths and backprop rigour, transformers written from scratch, LLM fine-tuning with RAG and evals, diffusion, multimodal and speech, alignment, deployment and a capstone.
120 hours, unit by unit
This is the complete Mastery syllabus — the ceiling of the stream, and what every level below builds toward.
The outcome
You can build, train, fine-tune, evaluate and deploy modern deep-learning systems — CNNs for vision, sequence models, transformers, LLM applications with fine-tuning and RAG, and diffusion pipelines — with a rigorous grasp of the mathematics underneath.
How it runs
120 hours · 60 sessions × 2 hours · about 3 months. Prerequisite: Data Science L2/L3 or a placement check — you should be comfortable with Python and ML basics. GPU-heavy labs run on cloud GPU, so no local GPU is required.
Tools & environment
Deliberate stack choice: PyTorch throughout, not TensorFlow — it is what research and most production teams actually use.
| Unit | What you learn and build | Sessions | Hours |
|---|---|---|---|
| U1 · Mathematics for DL | Linear algebra for deep learning · gradients, chain rule, backpropagation · optimization (SGD, momentum, Adam), learning-rate schedules · loss functions · probability and information theory — entropy, cross-entropy, KL | 4 | 8 |
| U2 · Neural Networks & PyTorch | Perceptron to MLP · activations · backprop written from scratch · PyTorch tensors and autograd · training loops, datasets and dataloaders · regularization (dropout, batch/layer norm), weight init · debugging training runs | 6 | 12 |
| U3 · CNNs & Computer Vision | Convolutions, pooling, feature maps · architectures from LeNet to ResNet and EfficientNet · image classification · transfer learning · object detection with YOLO, segmentation intro · data augmentation · OpenCV integration | 6 | 12 |
| U4 · Sequence Models | Sequential data · RNN, LSTM, GRU · vanishing gradients · time-series forecasting · seq2seq · attention intuition as the bridge to transformers | 5 | 10 |
| U5 · Natural Language Processing | Text preprocessing and tokenization · embeddings (Word2Vec, GloVe, FastText) · neural NLP for classification, NER and summarization · topic modeling · evaluating NLP systems | 5 | 10 |
| U6 · Transformers | Self-attention from scratch, multi-head attention · positional encoding, residuals and layer norm · encoder-only (BERT), decoder-only (GPT), encoder-decoder (T5) · tokenization (BPE, WordPiece) · pretraining objectives · Hugging Face Transformers | 6 | 12 |
| U7 · Large Language Models | The LLM landscape and scaling laws · prompt engineering · fine-tuning — full versus PEFT/LoRA · quantization (FP16/INT8, GGUF) · RAG with embeddings, vector DBs and chunking · agents, tool use and function calling · evals — perplexity, benchmarks, human eval, hallucination · RLHF concept · responsible AI, bias, prompt injection | 6 | 12 |
| U8 · Generative Image AI | GANs versus VAEs versus diffusion · forward and reverse process, noise schedules · U-Net and latent diffusion · CLIP text conditioning · samplers (DDIM, Euler, DPM++) · img2img, inpainting, ControlNet · ComfyUI node workflows | 5 | 10 |
| U9 · Fine-tuning & Deployment | LoRA for LLMs and diffusion — dataset prep, captioning, rank and alpha · quantization and optimization · serving with vLLM and FastAPI wrappers · Docker · cloud and serverless GPU · monitoring, cost and API security | 4 | 8 |
| U10 · Multimodal & Speech AI | Vision-language models (CLIP, LLaVA) · combined image-and-text tasks · speech — ASR with Whisper and TTS · audio deep-learning basics | 5 | 10 |
| U11 · Advanced Generative & Alignment | GANs and VAEs in depth · advanced diffusion · RLHF and DPO for preference alignment · distillation and efficiency | 5 | 10 |
| U12 · Capstone | Scope → build or fine-tune → evaluate → deploy → present a live demo | 3 | 6 |
| Total | 60 | 120 |
The capstone
Choose one track and take it end to end, deployed with a live demo:
(a) An applied CV system — detection or segmentation trained in PyTorch and served as an API. (b) An LLM application — a fine-tuned or RAG-based assistant with citations and an eval harness. (c) A generative pipeline — a custom LoRA plus ControlNet and ComfyUI workflow, packaged and reproducible.
You deliver: a deployed system, a repository, an evaluation report and a live demo.
How you're assessed
Syllabus is a working draft — hours per unit are indicative and validated by the practitioner who teaches the stream. Reinforcement learning appears only as the RLHF concept in U7; a full RL module is out of scope.
Who will teach you
Every instructor is currently building in the field they teach — and is certified on our level template before taking a cohort alone. Subject expertise is the entry ticket, not the job.
Practitioners, not lecturers
Every instructor is currently building in the field they teach. If they stop practising, they stop teaching that stream.
Trained on our template
Subject knowledge is the entry ticket, not the job. Every instructor is certified on the CEFTA level template before they take a cohort alone.
Standardized delivery
The same module runs the same way in every centre and every partner campus. That consistency is the product.
Named instructor profiles go up as each cohort's trainer is confirmed — we publish people, not stock photographs. We're hiring practitioner-instructors →
Tell me when the next batch opens
One email when a cohort is published for this stream. Nothing else, ever.
Understand the models, don't just use them.
Start with the free 3-hour L0 Discover session — see a network learn, then decide whether to climb.