Introduction to Large Language Models

# Introduction to Large Language Models

**What they are, how they work, and why they matter**

Shlok Nangia · May 2026

Note:
Welcome! This deck covers LLM fundamentals. Press S to toggle these speaker notes. Use arrow keys to navigate — right/left for sections, up/down for sub-slides within a section.

---

## Agenda

1. What is an LLM?
2. How do they work?
   - Tokenization
   - Attention mechanism
   - Training
3. Using an LLM in code
4. Math behind attention
5. Resources

Note:
We'll move quickly through the overview and spend more time on the attention mechanism and code examples.

---

## What is an LLM?

A **Large Language Model** is a neural network trained on massive text corpora to predict the next token in a sequence.

- Trained on hundreds of billions of tokens
- Learns grammar, facts, reasoning, and style implicitly
- Examples: GPT-4, Claude, Gemini, Llama

> "A language model is just a probability distribution over sequences of tokens."

Note:
Keep this definition simple for now. The "large" in LLM refers to both parameter count (billions) and training data scale.

___

### Scale matters

| Model       | Parameters | Release |
|-------------|-----------|---------|
| GPT-2       | 1.5 B     | 2019    |
| GPT-3       | 175 B     | 2020    |
| GPT-4       | ~1.8 T*   | 2023    |
| Llama 3.1   | 405 B     | 2024    |

\* estimated

Note:
These numbers are estimates for closed models. The key insight is that capability scales surprisingly smoothly with compute and data — the "scaling laws" paper by Kaplan et al. (2020).

___

### Emergent capabilities

As scale increases, models develop abilities not explicitly trained:

- Multi-step reasoning
- Code generation
- In-context learning (few-shot)
- Tool use

These abilities **emerge** rather than being explicitly programmed.

---

## Tokenization

Text is broken into **tokens** before the model sees it.

```python
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("gpt2")

text = "Hello, world! LLMs are fascinating."
tokens = tokenizer.encode(text)
decoded = tokenizer.convert_ids_to_tokens(tokens)

print(tokens)
# [15496, 11, 995, 0, 27140, 10128, 389, 23073, 13]

print(decoded)
# ['Hello', ',', 'Ġworld', '!', 'ĠLL', 'Ms', 'Ġare', 'Ġfascinating', '.']
```

Note:
Notice that "LLMs" splits into two tokens: "LL" and "Ms". Token boundaries don't align with word boundaries — this affects how models handle rare words and code.

---

## The Attention Mechanism

The core innovation of the Transformer architecture.

$$
\text{Attention}(Q, K, V) = \text{softmax}\!\left(\frac{QK^\top}{\sqrt{d_k}}\right)V
$$

Where:
- **Q** — Query matrix
- **K** — Key matrix  
- **V** — Value matrix
- **d_k** — dimension of keys (scaling factor)

Note:
The sqrt(d_k) scaling prevents the dot products from growing too large in magnitude, which would push softmax into regions with very small gradients.

___

### Multi-Head Attention

Rather than a single attention pass, Transformers run **h** attention heads in parallel:

$$
\text{MultiHead}(Q,K,V) = \text{Concat}(\text{head}_1,\ldots,\text{head}_h)\,W^O
$$

$$
\text{where} \quad \text{head}_i = \text{Attention}(QW_i^Q,\, KW_i^K,\, VW_i^V)
$$

Each head can attend to different parts of the sequence simultaneously.

Note:
Think of each head as a different "type" of relationship the model learns — one might track syntactic dependencies, another might handle co-reference.

---

## Calling an LLM in Python

```python
from openai import OpenAI

client = OpenAI()  # reads OPENAI_API_KEY from env

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "Explain self-attention in one paragraph."
        }
    ],
    temperature=0.7,
    max_tokens=256,
)

print(response.choices[0].message.content)
```

Note:
The `temperature` parameter controls randomness. 0 = deterministic (greedy decoding), 1+ = more creative/random. For factual tasks, use low temperature. For creative tasks, use higher.

___

### Streaming responses

```python
stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Write a haiku about attention."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)
```

Streaming gives a much better user experience — tokens print as they're generated rather than waiting for the full response.

---

## Visualizing Attention

A single image centered on the slide:

![Attention heatmap showing which tokens attend to which](/img/img1.png)

*Each cell shows how strongly one token attends to another.*

Note:
To use your own image, place it in the `static/img/` folder. Reference it as `/img/your-file.png`. The path is relative to the site root, not the markdown file.

---

## Transformer Architecture

Two images side by side using inline HTML:

<div style="display:flex; gap:2rem; justify-content:center; align-items:center;">
  <figure style="margin:0; text-align:center;">
    <img src="/img/img1.png" alt="Encoder block" style="max-height:42vh;">
    <figcaption style="font-size:0.55em; opacity:0.7; margin-top:0.4em;">Encoder block</figcaption>
  </figure>
  <figure style="margin:0; text-align:center;">
    <img src="/img/img2.png" alt="Decoder block" style="max-height:42vh;">
    <figcaption style="font-size:0.55em; opacity:0.7; margin-top:0.4em;">Decoder block</figcaption>
  </figure>
</div>

Note:
Inline HTML works inside Reveal.js markdown slides. Use flex layouts for side-by-side images. Keep max-height around 40–50vh so the image doesn't crowd the slide.

---

## How Attention Works

- Each token **queries** all other tokens
  - Similarity scores are computed via dot product
  - Scores are **softmax-normalized** into weights
  - The output is a **weighted sum** of value vectors

> The model learns which tokens to pay attent ion to — no hand-crafted rules.

</div>
  <figure style="flex:1; margin:0; text-align:center;">
    <img src="/img/img1.png" alt="Attention diagram" style="max-height:45vh; width:100%; object-fit:contain;">
    <figcaption style="font-size:0.85em; opacity:0.65; margin-top:0.5em;">Self-attention over a token sequence</figcaption>
  </figure>
</div>

Note:
The left-right split is a clean layout for "concept + visual" slides. Use flex:1 on both columns for an even 50/50 split, or flex:0.8 / flex:1.2 to give more room to either side.

---

## Training at a Glance

LLMs are pre-trained with **next-token prediction** (causal language modeling):

$$
\mathcal{L} = -\sum_{t=1}^{T} \log P(x_t \mid x_{<t};\, \theta)
$$

Then fine-tuned with **RLHF** (Reinforcement Learning from Human Feedback) to align with human preferences.

![Training pipeline](https://upload.wikimedia.org/wikipedia/commons/thumb/4/4c/ChatGPT_diagram.svg/640px-ChatGPT_diagram.svg.png)

Note:
The loss function is just cross-entropy over the vocabulary. What's remarkable is that this simple objective — predict the next word — forces the model to learn essentially everything about language and the world.

---

## Key Takeaways

- LLMs are **next-token predictors** trained at massive scale
- **Attention** allows every token to attend to every other token
- **Tokenization** is the bridge between raw text and model input
- **Temperature** and sampling strategies control output quality
- **Prompt engineering** and **fine-tuning** are your main levers for customization

---

## Custom Backgrounds

You can set a per-slide background with a comment right after `---`:

```markdown
---

```

Options:

| Type | Example value |
|------|--------------|
| Solid color | `"#1a1a2e"` |
| Gradient | `"linear-gradient(135deg, #0f2027, #2c5364)"` |
| Image | `"/img/img1.png"` |
| Image + dim | `data-background="/img/img1.png" data-background-opacity="0.3"` |

Note:
This slide itself uses a gradient background as a live demo. The comment must be the very first line after the --- separator — no blank line between them.

---

## Resources

- [Attention Is All You Need](https://arxiv.org/abs/1706.03762) — Vaswani et al. (2017)
- [The Illustrated Transformer](https://jalammar.github.io/illustrated-transformer/) — Jay Alammar
- [Andrej Karpathy — Let's build GPT](https://www.youtube.com/watch?v=kCc8FmEb1nY)
- [OpenAI API Docs](https://platform.openai.com/docs)
- [Hugging Face Transformers](https://huggingface.co/docs/transformers)

---

# Thank You

Questions? Let's talk.

[linkedin.com/in/shloknangia](https://www.linkedin.com/in/shloknangia) &nbsp;·&nbsp; [github.com/shloknangia](https://github.com/shloknangia)

Note:
End of presentation. If presenting live, this is a good time to open for Q&A.

← → navigate | S speaker notes | F fullscreen | ESC overview | L laser pointer