Use simple probability ideas to make sense of model confidence, uncertainty, and surprising outputs. You will connect likelihood, loss, and perplexity to the way language models are trained and judged.

Follow how a model improves by comparing its predictions with real examples. This chapter covers training data, parameters, gradients, overfitting, validation, and what “learning” means in a neural network.

Trace the path from rule-based chatbots and n-gram models to transformers, GPT-style systems, instruction-tuned assistants, and today’s foundation models. The focus is on the ideas and computing shifts that made LLMs possible.

Work with the older methods that still appear in real systems: regular expressions, TF-IDF, stemming, named entity recognition, and simple classifiers. These tools help with data cleaning, retrieval, evaluation, and fallback behavior around LLMs.

Build the core picture of layers, weights, activations, and backpropagation. You will see why neural networks can learn language patterns that hand-written rules cannot cover.

Use embeddings to represent meaning, similarity, and relationships between pieces of text. This chapter covers word embeddings, sentence embeddings, semantic search, clustering, and common failure cases.

See how attention lets a model weigh which earlier tokens matter for the next token. You will work through queries, keys, values, attention scores, and why attention changed natural language processing.

Put attention, feed-forward layers, residual connections, layer normalization, and positional information into one working mental model. This chapter explains decoder-only transformers, the architecture behind most modern LLMs.

Control how a trained model writes by changing temperature, top-k, top-p, penalties, seeds, and stop rules. You will practice choosing decoding settings for factual answers, creative writing, extraction, and code.

Prepare the raw material of LLM training: web text, books, code, conversations, metadata, filters, deduplication, and data documentation. This chapter also covers contamination, personally identifiable information, and quality signals.

Train a small language model so the full loop becomes concrete. You will connect tokens, batches, loss curves, checkpoints, validation, and generated samples without needing massive infrastructure.

See what changes when training moves from a laptop to clusters of GPUs or TPUs. This chapter covers memory limits, batching, mixed precision, parallelism, checkpoints, failures, and the practical reasons training is expensive.

Use scaling laws to reason about model size, data size, compute, and expected performance. You will also compare dense models, model families, checkpoints, and the tradeoffs behind “bigger is better.”

Study mixture-of-experts models, where only part of a large model runs for each token. This chapter covers routing, expert capacity, training instability, inference tradeoffs, and why sparse models became important for large-scale LLMs.

Handle long documents, long chats, and large context windows without losing track of the task. You will cover positional methods, context packing, summarization, memory patterns, and the limits of “just add more context.”

Work with models that combine text with images, audio, video, documents, or screen actions. This chapter covers vision-language models, OCR-like use cases, multimodal prompting, and evaluation problems unique to non-text inputs.

See how smaller models can run on phones, laptops, browsers, and private servers. This chapter covers distillation, quantization-aware choices, local runtimes, privacy tradeoffs, and when small models beat large hosted models.

Turn a raw pretrained model into one that follows requests, formats answers, and behaves like an assistant. You will cover supervised instruction data, chat templates, system messages, and common instruction-tuning mistakes.

Shape model behavior using human or AI preferences. This chapter covers RLHF, RLAIF, reward models, DPO-style training, preference datasets, and the tradeoff between helpfulness, honesty, and harmlessness.

Handle refusals, unsafe requests, sensitive topics, and policy boundaries with more than a vague ethics checklist. You will cover safety datasets, red-team prompts, harmlessness tuning, over-refusal, and behavior testing.

Use model-generated data to improve training, evaluation, and task coverage. This chapter covers synthetic instructions, self-play, data filtering, teacher-student setups, and the risks of feedback loops and low-diversity data.

Adapt a pretrained model to a domain or task by continuing training on selected data. You will compare full fine-tuning, continued pretraining, supervised fine-tuning, data mixes, evaluation sets, and rollback plans.

Use LoRA, QLoRA, adapters, and prompt tuning to adapt models with less compute. This chapter covers rank, target modules, merging, storage, serving, and when parameter-efficient tuning is the right tool.

Write prompts that make model behavior easier to predict and test. You will practice clear task framing, examples, constraints, role instructions, decomposition, and prompt versioning.

Get machine-readable answers instead of fragile prose. This chapter covers JSON mode, schemas, constrained decoding, function calling, tool signatures, validation, retries, and error handling.

Use hosted model APIs, open-weight models, and local runtimes in a practical way. You will handle authentication, rate limits, streaming, batching, model parameters, logging, and basic cost controls.

Choose a model based on the job instead of hype. This chapter covers open vs closed models, license terms, context length, latency, price, privacy, benchmarks, domain fit, and operational risk.

Build semantic search with embeddings, chunking, indexes, vector databases, metadata filters, and reranking. You will see how retrieval quality depends on data preparation as much as the embedding model.

Build retrieval-augmented generation from question to cited answer. This chapter covers query rewriting, chunk retrieval, reranking, context assembly, citation handling, answer grounding, and failure analysis.

Connect models to calculators, databases, search, calendars, code execution, and business systems. You will design tool schemas, manage permissions, inspect tool traces, and prevent the model from inventing tool results.

Use LLMs for code completion, explanation, refactoring, tests, and debugging. This chapter covers code-specific models, repository context, generated test cases, review habits, and security risks in AI-written code.

Improve performance on tasks that require multi-step thought, math, planning, or verification. You will cover decomposition, scratchpads, self-checking, verifiers, search over candidate answers, and when these methods fail.

Create evaluation sets that reflect real user needs and known risks. This chapter covers golden datasets, rubric grading, LLM-as-judge methods, benchmark limits, statistical confidence, and regression testing.

Test models against hallucination, bias, toxicity, privacy leakage, jailbreaks, and domain-specific harm. You will build red-team cases, score failures, prioritize fixes, and decide what must block release.

Design chatbots, copilots, and assistants that people can actually use. This chapter covers conversation flow, clarification questions, citations, confidence signals, handoff to humans, accessibility, and user feedback.

Follow one realistic project from request to production: define the task, choose a model, prepare data, build prompts or RAG, evaluate, secure, launch, and monitor. This chapter ties the whole practice into a repeatable workflow.

Serve LLMs with attention to latency, throughput, reliability, and capacity. You will cover model servers, streaming, autoscaling, queues, retries, timeouts, fallbacks, and service-level objectives.

Reduce cost and speed up responses without breaking quality. This chapter covers caching, batching, quantization, speculative decoding, prompt compression, routing, distillation, and smaller fallback models.

Track what happens after launch using traces, prompts, outputs, user feedback, quality scores, and cost metrics. You will set up monitoring for drift, regressions, abuse, outages, and silent quality loss.

Defend against prompt injection, data exfiltration, malicious files, unsafe tool calls, and model-assisted abuse. This chapter covers threat modeling, sandboxing, least privilege, input handling, output filtering, and incident response.

Handle private data, copyrighted material, data retention, consent, licenses, and audit needs. You will make practical decisions about training data, logs, vendors, user uploads, and generated content.

Document and govern LLM systems so teams can trust and maintain them. This chapter covers model cards, data sheets, risk registers, approval workflows, change control, audit trails, and emerging AI regulations.

Map the field’s roles, specialties, and proof-of-skill artifacts: LLM app developer, ML engineer, data engineer, evaluator, safety researcher, product builder, and infrastructure engineer. You will plan projects, portfolios, communities, papers, benchmarks, and habits that keep your skills current.