Large Language Models (LLMs)

Understand supervised and unsupervised learning, loss functions, gradient descent, and overfitting. These are the building blocks every ML system relies on.

Learn how layers of neurons compose to approximate complex functions, including backpropagation, activation functions, and common architectures like MLPs and CNNs.

Explore how computers process human language — tokenization, bag-of-words, TF-IDF, and the challenges of representing meaning in text.

Understand how words are mapped to dense vector spaces (Word2Vec, GloVe) where semantic relationships are preserved as geometric structure.

Learn how recurrent neural networks process sequential data, including LSTMs, GRUs, and the encoder-decoder pattern for sequence-to-sequence tasks.

You now understand the core ML and NLP concepts that motivated the development of transformers and LLMs.

Understand how attention lets a model dynamically focus on relevant parts of the input, solving the information bottleneck problem of fixed-size hidden states.

Learn how self-attention computes query-key-value relationships within a sequence, and how multiple heads capture different types of relationships in parallel.

Understand how transformers inject sequence order information since self-attention is permutation-invariant — covering sinusoidal, learned, and rotary position embeddings.

See how attention, layer normalization, and feed-forward networks compose into transformer blocks, and how stacking them creates the full encoder-decoder or decoder-only architecture.

Compare the three transformer variants (BERT-style, GPT-style, T5-style) and understand why decoder-only models became dominant for generative LLMs.

You can explain how a transformer processes text from input tokens to output probabilities, and why this architecture replaced RNNs.

Learn how raw text is split into subword tokens that the model processes — including byte-pair encoding, unigram models, and the tradeoffs of vocabulary size.

Understand causal language modeling (next-token prediction) and masked language modeling, and why the pretraining objective shapes what the model learns.

Explore where LLM training data comes from (Common Crawl, books, code), how it is filtered and deduplicated, and how data quality directly affects model capability.

Learn the empirical relationships between model size, data size, and compute budget (Chinchilla scaling laws) that guide how to allocate resources for training.

Understand data parallelism, model parallelism, pipeline parallelism, and mixed-precision training — the engineering that makes training billion-parameter models feasible.

You understand how a raw transformer becomes a capable language model through large-scale pretraining on text data.

Learn how instruction-following datasets are used to fine-tune a pretrained model so it produces helpful, structured responses instead of raw text completions.

Understand how human preference data trains a reward model, which then guides policy optimization (PPO) to align model outputs with human values and preferences.

Learn Direct Preference Optimization and related methods that skip the reward model step, directly optimizing the policy from preference pairs — simpler and increasingly popular.

Understand how low-rank adapters let you fine-tune large models on consumer hardware by training only a small fraction of the parameters.

Explore how models can critique and revise their own outputs using a set of principles, reducing reliance on human feedback for alignment.

You understand how pretrained models are shaped into assistants that follow instructions, respect preferences, and behave safely.

Learn how to write effective prompts — system messages, few-shot examples, formatting instructions, and the impact of prompt structure on output quality.

Understand how prompting a model to think step-by-step dramatically improves performance on complex reasoning, math, and logic tasks.

Learn how to ground LLM responses in external knowledge by retrieving relevant documents at inference time, reducing hallucination and enabling domain-specific answers.

Understand how LLMs can invoke external tools, APIs, and functions — turning a text generator into an agent that can take actions in the real world.

Explore agentic architectures where LLMs plan, execute multi-step tasks, use tools, and maintain state — including frameworks like ReAct, reflection, and multi-agent systems.

Learn techniques for getting LLMs to produce valid JSON, XML, or code — including grammar-constrained decoding and output parsers.

You can design effective prompts, build RAG pipelines, and orchestrate LLM agents for real-world applications.

Understand key-value caching, continuous batching, speculative decoding, and other techniques that make LLM inference fast and cost-efficient at scale.

Learn how reducing model precision from 16-bit to 8-bit or 4-bit dramatically cuts memory and compute costs with minimal quality loss.

Explore how to measure LLM quality — automated benchmarks (MMLU, HumanEval), LLM-as-judge, human evaluation, and the challenges of evaluating open-ended generation.

Understand prompt injection, jailbreaking, content filtering, and defense strategies for deploying LLMs safely in user-facing applications.

Learn practical strategies for managing LLM costs — caching, model routing, prompt optimization, and choosing between hosted APIs vs self-hosting.

Explore how modern LLMs process images, audio, and video alongside text — architectures like vision transformers and cross-modal attention.

You can deploy, optimize, evaluate, and secure LLM-powered applications in production environments.