LLM Foundations (LLM Bootcamp)

Large language models work because they turn text into numbers, then learn—via gradient-based training—to predict the next token using a Transformer architecture built for parallel computation. That “next-token” setup matters because it unifies many learning styles under one practical training loop: inputs and outputs become vectors, a loss function measures prediction error, and backpropagation adjusts millions to billions of parameters until the model generalizes.

The foundation starts with a shift from “software 1.0” to “software 2.0.” Traditional programming encodes explicit rules and edge cases. Machine learning instead trains a system that produces a new behavior from data, where the learned robot is driven by parameters that are hard to interpret directly. Within that framing, unsupervised, supervised, and reinforcement learning have largely converged in modern practice into self-supervised learning: models learn by predicting missing or future parts of data, and reinforcement-style objectives can often be reformulated as supervised prediction problems.

Neural networks dominate because they can be expressed as matrix multiplications, and GPUs make those operations fast. Training typically uses mini-batches, computes a loss (commonly cross-entropy for classification-style token prediction), and updates parameters through backpropagation. Data is split into training, validation, and test sets: validation loss guides stopping and hyperparameter choices to reduce overfitting, while the test set stays mostly untouched to approximate real-world performance.

At the architecture level, the Transformer—introduced in “Attention Is All You Need” (2017)—is the core engine. Its decoder predicts the next token by repeatedly attending over previously seen tokens. Attention works by comparing token representations: each token becomes a “query,” “key,” and “value,” and the model forms weighted sums of values where weights reflect similarity between queries and keys. Multi-head attention lets the model learn several attention patterns at once (implemented efficiently as projections into multiple subspaces). During training, masking prevents the model from “looking ahead,” ensuring predictions depend only on earlier context.

Because attention itself is order-agnostic, positional encoding injects information about token order. Residual (skip) connections and layer normalization stabilize training and help gradients flow through many layers. A Transformer block also includes a feed-forward network that transforms token representations into more semantic features. Stacking these blocks yields models with varying depth, embedding size, and attention heads; GPT-3 is cited as having 175 billion parameters with 96 layers and 12,000 embedding dimensions.

Modern LLMs differ mainly in training objectives and data pipelines. BERT is encoder-only and uses masked-word prediction, while T5 reframes tasks as text-to-text generation. GPT models are decoder-only and use next-token prediction with causal masking. Tokenization commonly uses byte pair encoding, balancing vocabulary size with the ability to represent rare characters.

Scaling laws and compute allocation shape performance. DeepMind’s “Training Compute-Optimal LMs” (Chinchilla) argues that many models use too many parameters for the amount of data seen; a smaller model trained on more tokens (70B parameters vs. a much larger baseline) can outperform when compute is held fixed. Meta’s Llama is presented as an open-weight, Chinchilla-optimal family trained on large corpora (including filtered Common Crawl, GitHub, Wikipedia, and books) and released in multiple sizes.

Finally, instruction following and retrieval are treated as separate levers. Instruction tuning uses supervised fine-tuning and often reinforcement learning from human feedback to shift behavior from raw text completion toward following user commands in chat formats. Fine-tuning can improve instruction compliance but may reduce calibration and few-shot abilities (“alignment tax”). Retrieval-enhanced approaches like DeepMind’s RETRO aim to let smaller models fetch factual context from large databases, pointing toward systems that combine reasoning with external knowledge.