Notes on Online Degree: Large Language Models

Large language models are neural networks trained to predict and generate text, and they now power many tools that read, write, and reason over language. This note explains the core ideas behind them and how a learner can build working understanding step by step.

What Language Models Actually Do

At its heart, a language model assigns probabilities to sequences of tokens, estimating how likely a word or word piece is to follow a given context. This simple objective, repeated across enormous amounts of text, forces the model to absorb grammar, facts, style, and reasoning patterns as useful side effects. Learners should begin with probability and perplexity, because these ideas explain how a model is scored and why a lower score usually means the model predicts language more accurately. Understanding how text is split into tokens and vocabularies is equally important, since tokenization shapes cost, context length, and how a model handles unusual words or code. Many of the surprising behaviors of modern systems trace back to these foundations, so time spent here pays off throughout the rest of the subject.

A useful way to grasp the field is to see how it developed, from early statistical n-gram models to neural approaches that learn distributed representations of words. Word embeddings showed that meaning could be encoded as geometry, with related words placed near one another in a learned space. Context windows then set the limit on how much text a model can consider at once, which affects everything from document summarization to multi-turn conversation. Learners who understand these building blocks can reason clearly about why a model behaves the way it does rather than treating it as a black box. This conceptual grounding is the starting point for every technical choice discussed later in the course. Learners who want a structured path can follow Online Degree: Large Language Models to work through these foundations in order.

Inside the Transformer Architecture

The transformer is the architecture behind nearly every modern large language model, and its central mechanism is self-attention. Self-attention lets each token compute how strongly it should relate to every other token in the sequence, producing context-aware representations that reflect the surrounding text. Multi-head attention runs several of these comparisons in parallel so the model can track different kinds of relationships at the same time, such as syntax, reference, and topic. Because attention alone does not capture order, positional encoding injects information about where each token sits in the sequence. Feed-forward sublayers, activation functions, layer normalization, and residual connections complete each block and keep deep stacks trainable. Learners should trace the flow of a single token through these components until the data path feels concrete.

Once the architecture is clear, learners can see how its parts interact in practice and where design choices change behavior. Increasing depth, width, or the number of attention heads alters both capacity and compute cost, which is why engineers think carefully about trade-offs. Residual connections and normalization are less glamorous than attention, yet they are what make training stable at scale. Practitioners who understand these details can diagnose problems such as slow convergence, memory limits, or unexpected output patterns. The goal is not to memorize every equation but to build an accurate mental model that supports good decisions. This knowledge becomes the foundation for pretraining, adaptation, and deployment work covered later.

From Pretraining to Specialized Behavior

Pretraining is the stage where a model learns general language patterns from very large text collections, and it involves choices about data collection, filtering, tokenization, and the training objective. These decisions determine what the model knows and how it will fail, so responsible practitioners treat data quality as a core engineering concern. Compute requirements also shape what is feasible, and learners should understand how training budget, model size, and dataset size interact. After pretraining, a base model is adapted to specific tasks through supervised fine-tuning and instruction tuning, which teach it to follow directions and produce useful responses. Parameter-efficient methods such as LoRA and adapters make this adaptation far cheaper by updating a small set of added parameters rather than the full network. Comparing these approaches helps learners choose the right level of customization for a given goal.

Alignment is the next layer, and reinforcement learning from human feedback is one widely used method for shaping model behavior toward human preferences. In this process, human judgments are used to train a reward signal that guides the model toward responses people find more helpful and safe. Learners should appreciate both its power and its limits, since preference data can carry bias and the reward signal can be gamed. Understanding this stage clarifies why two models built from the same base can feel very different to users. Taken together, pretraining, fine-tuning, and alignment describe the full path from raw text to a dependable assistant. Practitioners who grasp this pipeline are better equipped to evaluate vendor claims and plan their own projects.

Prompting, Retrieval, and Evaluation in Practice

Working with a deployed model often begins with prompt engineering, the discipline of framing a request so the model returns what is needed. Zero-shot prompting relies on the model's general knowledge, while few-shot prompting supplies examples that demonstrate the desired pattern. Chain-of-thought and structured prompting encourage step-by-step reasoning and consistent output formats that downstream software can parse. These techniques are inexpensive to try and often produce large gains, but they must be tested rather than assumed to work. Learners should practice writing prompts, comparing results, and documenting what changes improve quality. Prompt design is a skill that rewards careful iteration and clear thinking about the task.

When a model must rely on current or proprietary information, retrieval-augmented generation offers a way to ground answers in external sources. A retrieval system finds relevant passages, which are then supplied to the model as context so its response is anchored to documents rather than memory alone. Designing this pipeline involves choices about chunking, indexing, ranking, and how retrieved evidence is cited. Evaluation ties all of these pieces together, using benchmarks, human review, and automated quality metrics to judge whether a system is actually improving. Learners who build a habit of measuring output quality, rather than trusting impressions, become much more effective at deploying these systems responsibly. Across every stage of the lifecycle, disciplined evaluation is what turns experimentation into reliable practice.