Skip to main content
I want to start with something that surprises almost everyone the first time they hear it. ChatGPT, Claude, or that assistant embedded in your company’s tools—behind each of them sits a model. A model isn’t a hand-coded program of rules. Instead, it is essentially one large file (often tens or hundreds of gigabytes) whose contents determine everything the model does. So how does this large, static file answer your questions? This lesson explains exactly that.

​
What is an LLM?

LLM stands for large language model. Training begins with raw text at massive scale: books, documentation, websites, source code, forum posts—anything representable as text. No explicit rules, templates, or grammar are given to the model. It must learn linguistic patterns, facts, styles, and code structure purely from examples in the training data. Key ideas:
  • The model ingests tokens (words, subwords, punctuation) from raw text.
  • It learns statistical patterns that let it predict likely next tokens given a prompt.
  • All learned knowledge is encoded numerically inside the model file.

​
Training: predict, compare, adjust

Training is conceptually simple, though computationally expensive. The model repeatedly practices predicting the next token in sequences from the training data. For each prediction the training loop:
  • makes a guess for the next token,
  • compares the guess to the actual next token,
  • computes the error (the loss),
  • nudges the model’s internal numbers slightly to reduce that error.
This cycle repeats billions (or trillions) of times across many examples and typically runs on thousands of GPUs for days or weeks. That massive distributed computation is why training large models can cost millions of dollars and drives high GPU demand.

​
Parameters = learned knowledge

All those incremental updates are stored in the model’s parameters (also called weights). Think of parameters as billions of tiny dials—each training example turns some dials a little. The final dial positions encode what the model “knows”: language structure, common facts, reasoning patterns, and code formatting. Common parameter-scale examples:
  • Small models: millions–few billions of parameters.
  • Mid-size models: several billion parameters.
  • Frontier models: tens to hundreds of billions of parameters (e.g., a model labeled “70B” typically has around 70 billion parameters).
Once training finishes, these parameter values are frozen. That moment is often referred to as the model’s freeze or cutoff date. After that date, the file does not change unless the model is explicitly retrained or fine-tuned offline.

​
Training vs. inference — one-time build, cheap queries

Everything that happens before the freeze is training—one-time and costly. Everything after is inference—the model answering prompts using its frozen parameters. At inference time the model performs the same predict-loop, but without updating parameters:
  • You provide a prompt (question, context, system instructions).
  • The model predicts one token, appends it to the context, then repeats predict → append → repeat.
  • Many services stream those tokens as they are generated; you’re watching that predict-loop run in real time.
Because parameters do not change during inference, the model is generating tokens from statistical patterns—it is not performing a database-style lookup inside its weights.

​
Practical consequences

  1. The base model cannot learn from your individual conversations in real time. You can correct the model within a session or craft prompts that steer behavior, but the underlying parameters remain unchanged. To permanently incorporate user feedback requires collecting data and performing offline retraining or fine-tuning.
  2. The model’s knowledge is fixed at the freeze date—this is the knowledge cutoff. If you ask about events, APIs, or facts that appeared after that date, the base model may not know them. That’s why model documentation always lists a knowledge cutoff.
  3. Many deployed assistants combine a frozen model with external systems (retrieval, web search, databases). Those augmented systems can supply up-to-date facts. Still, the core model is only doing token prediction; it’s using the externally retrieved content as part of the prompt to generate answers. This pattern is often called retrieval-augmented generation (RAG).
A presenter stands beside a glowing lightboard covered with neon-colored diagrams and handwritten labels. The board illustrates the LLM workflow—text sources, training with GPUs, a frozen model, prompts, and responses.
Prediction, not lookup — the model generates text one token at a time based on frozen parameters and the prompt. Any up-to-date or ground-truth information must be provided through external retrieval or offline retraining.

​
Quick glossary

  • Token: a piece of text (word, subword, or punctuation) the model predicts.
  • Parameter / Weight: a numeric value in the model file that the model learned during training.
  • Knowledge cutoff: the date after which the model received no new training data.
  • Inference: running the frozen model to generate text in response to prompts.
  • Retrieval-augmented generation (RAG): an approach combining a frozen model with external data sources to provide current information.

​
Next step

Now that you understand what an LLM actually is and the difference between training and inference, the next question is: why do some models require hundreds of gigabytes while others fit on a laptop, and when should you choose a smaller model versus a large one? That decision depends on latency, cost, inference hardware, and the complexity of tasks you need the model to perform. Further reading and references:

Watch Video