10. Natural Language Processing and Large Language Models

📝 Text Preprocessing — Preparing Language for Models

Raw text cannot be fed directly to mathematical models. It must be converted into numerical representations through a preprocessing pipeline.

🔢 Text Representations — From Words to Vectors

Models need numbers, not words. The evolution of text representations tells the story of modern NLP:

Bag of Words (BoW): Represent text as a vector of word counts. Ignores word order entirely. Simple but surprisingly effective for simple classification tasks. Produces sparse, high-dimensional vectors.

TF-IDF (Term Frequency-Inverse Document Frequency): Weights words by how frequently they appear in a document (TF) relative to how common they are across all documents (IDF). Common words like "the" get low weights; rare, distinctive words get high weights. Better than raw counts for information retrieval and classification.

Word Embeddings (Word2Vec, GloVe): Dense vectors (typically 50–300 dimensions) where semantically similar words have similar vectors. "King - Man + Woman ≈ Queen" is the famous example—these vectors encode semantic relationships. Trained on large text corpora using self-supervised objectives (predict surrounding words, or predict a word from its context).

🔁 The Transformer Architecture — The Foundation of Modern AI

The Transformer, introduced by Vaswani et al. (2017) in "Attention Is All You Need," is the architecture underlying GPT, BERT, Claude, Gemini, and virtually every modern AI system working with language, audio, or video. Understanding it is non-negotiable for modern AI engineers.

The Core Innovation — Self-Attention:

Previous sequence models (RNNs, LSTMs) processed text sequentially—word by word—which prevented parallelization and made it hard to relate words far apart in a sequence. Self-attention allows each word to directly attend to every other word in the sequence simultaneously, computing a weighted representation based on relevance.

How Attention Works:

1. For each token, compute three vectors: Query (Q), Key (K), and Value (V) via learned weight matrices.
2. Compute attention scores: score(Q, K) = Q·K^T / √d_k where d_k is the key dimension. The division by √d_k prevents scores from becoming too large.
3. Apply softmax to scores to get attention weights summing to 1.
4. Compute the weighted sum of Value vectors: output = softmax(Q·K^T/√d_k) · V
5. The output for each token is now a context-aware representation that incorporates information from all other tokens, weighted by relevance.

Multi-Head Attention: Rather than computing a single attention function, Transformers run multiple attention heads in parallel, each learning to attend to different types of relationships (syntax, semantics, coreference). Their outputs are concatenated and projected.

The Full Transformer Block:

🤗 Hugging Face — NLP in Practice

🧬 Foundations of Large Language Models (LLMs)

Large Language Models are Transformer-based models trained on massive text corpora with billions of parameters. They represent the current frontier of AI capability. Understanding their architecture and training is essential for modern AI engineers.

The Pretraining Objective — Next Token Prediction: GPT-style models are trained on a deceptively simple objective: given the previous tokens in a sequence, predict the next token. This is called autoregressive language modeling or causal language modeling. Trained on hundreds of billions of tokens of internet text, the model must implicitly learn grammar, facts, reasoning patterns, programming, mathematics, and world knowledge—because all of these help predict the next token accurately.

Emergent Capabilities: LLMs exhibit capabilities that were not explicitly trained for and that scale predictably with model size. Chain-of-thought reasoning, in-context learning (learning from examples in the prompt), instruction following, and code generation all emerged as models scaled beyond certain parameter thresholds. This emergence is both fascinating and poorly understood.

RLHF — Aligning LLMs with Human Preferences: Raw pretrained LLMs generate text that completes the statistical pattern of training data—which can be harmful, biased, or unhelpful. Reinforcement Learning from Human Feedback (RLHF) fine-tunes the model to be helpful, harmless, and honest. Human raters compare LLM responses and rank them. A reward model is trained on these preferences. The LLM is then fine-tuned using RL to maximize the reward model's score. This is how ChatGPT, Claude, and Gemini are aligned.