Publications

One-way ANOVA, post-hoc tests, assumptions, and when to use ANOVA. Compare means across three or more groups while controlling Type I error rates.

F-distribution, F-test for comparing variances, F-test in regression, and nested model comparison.

Covers t-tests including one-sample, two-sample (pooled and Welch), paired tests, assumptions, and decision framework.

Mathematical equivalence between confidence intervals and hypothesis tests, test assumptions (independence, normality, equal variances).

Covers z-tests including one-sample, two-sample, and proportion tests. Topics include when to use z-tests, how to calculate test statistics.

Foundation of hypothesis testing covering p-values, null and alternative hypotheses, one-sided vs two-sided tests.

Covers DBSCAN (Density-Based Spatial Clustering of Applications with Noise), the algorithm.

Covers quadratic programming (QP) for portfolio optimization, including the mean-variance framework, efficient frontier construction.

Covers Vehicle Routing Problem with Time Windows (VRPTW), including mathematical formulation, constraint programming.

Covers minimum cost flow optimization for slotting problems, including network flow theory, mathematical formulation.

Covers Mixed Integer Linear Programming (MILP) for factory optimization, covering mathematical foundations, constraint modeling, branch-and-bound algorithms.

Covers CP-SAT rostering using Google OR-Tools to solve complex workforce scheduling problems with binary decision variables, coverage constraints.

Covers NHITS (Neural Hierarchical Interpolation for Time Series), a deep learning architecture for multi-scale time series forecasting.

Covers N-BEATS, an interpretable deep learning architecture for time series forecasting.

Covers HDBSCAN clustering algorithm covering density-based clustering, automatic cluster selection, noise detection.

Covers hierarchical clustering, including dendrograms, linkage criteria (single, complete, average, Ward), and scikit-learn implementation.

Covers SARIMA (Seasonal AutoRegressive Integrated Moving Average) for forecasting time series with seasonal patterns.

Covers exponential smoothing for time series forecasting, including simple, double (Holt's), and triple (Holt-Winters) methods.

Covers Prophet time series forecasting including additive decomposition, trend modeling, seasonal patterns, and holiday effects.

Covers K-means clustering from mathematical foundations to practical implementation. Topics include the algorithm, initialization strategies.

Covers t-SNE (t-Distributed Stochastic Neighbor Embedding), including mathematical foundations, probability distributions, KL divergence optimization.

Covers LIME (Local Interpretable Model-Agnostic Explanations), including mathematical foundations, implementation strategies.

Covers UMAP dimensionality reduction, including mathematical foundations, fuzzy simplicial sets, manifold learning.

Covers Principal Component Analysis, including mathematical foundations, eigenvalue decomposition.

Covers XGBoost (eXtreme Gradient Boosting), including second-order Taylor expansion, regularization techniques, split gain optimization, ranking loss functions.

Covers SHAP values covering mathematical foundations, feature attribution, and practical implementations for explaining any machine learning model.

Covers LightGBM gradient boosting framework, including leaf-wise tree growth, histogram-based binning, GOSS sampling, exclusive feature bundling.

Covers CatBoost (Categorical Boosting), including categorical feature handling, target statistics, symmetric trees, ordered boosting, regularization techniques.

Covers Isolation Forest covering unsupervised anomaly detection, path length calculations, harmonic numbers, anomaly scoring.

Covers boosted trees and gradient boosting, covering ensemble learning, loss functions, sequential error correction, and scikit-learn implementation.

Covers Random Forest covering ensemble learning, bootstrap sampling, random feature selection, bias-variance tradeoff, and implementation in scikit-learn.

Covers CART (Classification and Regression Trees), including mathematical foundations, Gini impurity, variance reduction.

Covers logistic regression covering mathematical foundations, the logistic function, optimization algorithms, and practical implementation.

Covers Poisson regression for count data analysis. Topics include mathematical foundations, maximum likelihood estimation, rate ratio interpretation.

Spline regression models nonlinear relationships with piecewise polynomials. Covers B-splines, knot selection, natural cubic splines, and Python.

Covers multinomial logistic regression covering mathematical foundations, softmax function, coefficient estimation.

Covers Elastic Net regularization, including mathematical foundations, geometric interpretation.

Model nonlinear relationships with polynomial regression. Covers feature construction, Python implementation, model selection, bias, variance, and overfitting.

Covers Ridge regression and L2 regularization, including mathematical foundations, geometric interpretation, bias-variance tradeoff.

Compare covariance, correlation, and regression for relationships between variables. Covers interpretation, assumptions, pitfalls, and Python examples.

Assess data quality through measurement error, systematic bias, missing-data mechanisms, and outlier detection. Covers diagnosis, treatment, and validation.

Covers statistical modeling fundamentals, including measuring model fit with R-squared and RMSE.

Covers core data visualization techniques including histograms, box plots, and scatter plots. Topics include distributions, identify outliers.

Covers the Gauss-Markov assumptions that underpin linear regression. Topics include the five key assumptions, how to test them, consequences of violations.

Covers normalization in machine learning, covering min-max scaling, proper train-test split implementation, when to use normalization vs standardization.

Covers sampling theory and methods in data science, covering simple random sampling, stratified sampling, cluster sampling, sampling error.

Covers probability distributions for data science, including normal, t-distribution, binomial, Poisson, exponential, and log-normal distributions.

Covers statistical inference, including point and interval estimation, confidence intervals, hypothesis testing, p-values, Type I and Type II errors.

Covers descriptive statistics fundamentals, including measures of central tendency (mean, median, mode), variability (variance, standard deviation, IQR).

Covers the Central Limit Theorem covering convergence to normality, standard error, sample size requirements.

Covers probability theory fundamentals, covering random variables, probability distributions, expected value and variance.

Classify data as quantitative or qualitative, discrete or continuous, and nominal, ordinal, interval, or ratio. Match each type to suitable analysis methods.

Covers standardization in machine learning, covering mathematical foundations, practical implementation.

Covers the Sum of Squared Errors (SSE) metric in regression analysis. Topics include the mathematical foundation, visualization techniques.

Covers L1 regularization (LASSO) in machine learning, covering mathematical foundations, optimization theory, practical implementation.

Multiple linear regression estimates how several predictors relate to an outcome. Covers OLS formulas, assumptions, interpretation, diagnostics, and Python.

Covers multicollinearity in regression analysis with this practical guide. VIF analysis, correlation matrices, coefficient stability testing.

Covers Ordinary Least Squares (OLS) regression, including mathematical derivations, matrix formulations, step-by-step examples, and Python implementation.

Simple linear regression models the relationship between one predictor and an outcome. Covers OLS formulas, assumptions, interpretation, and Python.

Covers R-squared, the coefficient of determination. Explains what R-squared means, how to calculate it, interpret its value.

Generalized linear models combine link functions with probability distributions. Covers logistic and Poisson regression, maximum likelihood, and Python.

Reduce LLM hallucination using retrieval augmentation, self-consistency decoding, DPO training, and calibrated uncertainty expression.

Reverse-engineer transformer networks into human-understandable algorithms by identifying circuits, induction heads, and mechanistic discoveries.

Examines the open problems, promising research areas, benchmark gaps, and community priorities shaping the future of language AI.

Explains how language AI reshapes labor markets, widens or narrows access gaps, drives regulatory frameworks.

Examines the core alignment challenges facing modern LLMs: scalable oversight, alignment tax, goal mis-specification, reward hacking.

Covers four methods for detecting LLM hallucinations: entailment-based scoring, knowledge base verification, self-consistency checks.

Explains how probing classifiers reveal what linguistic information is encoded in neural network representations.

Explains how language models hallucinate: intrinsic and extrinsic hallucination, factual errors, fabrication, and inconsistency with NLI-based detection.

Examines the structural causes of LLM hallucinations: training data noise, exposure bias, knowledge gaps, and generation pressure in language models.

Explains how language models cause harm through stereotyping, erasure, and demeaning associations, with measurement methods and concrete examples.

Examines emerging language model capabilities including in-context learning, chain-of-thought reasoning, world models, planning and agency.

Covers the key mathematical definitions of algorithmic fairness, from demographic parity to equalized odds.

Examines efficient transformer architectures, hardware co-design, inference optimizations like speculative decoding.

Examine the physical, statistical, and economic limits of LLM scaling, the data wall crisis, and architectural innovations like MoE and inference-time compute.

Practical techniques for reducing demographic bias in language models: data balancing, embedding debiasing, adversarial training.

Measure bias in language models using embedding association tests, generation metrics, classification fairness measures, and standard benchmarks.

Write model cards that communicate intended use, training data, evaluation results, and limitations for responsible AI deployment.

Explains how language models inherit demographic, cultural, and occupational bias from training data, and why they amplify these biases beyond the data.

Explains how token-level watermarking embeds hidden statistical signals into LLM outputs, enabling cryptographically verifiable attribution and AI provenance.

Design reliable LLM judge prompts using explicit criteria, few-shot examples, and chain-of-thought formatting to maximize evaluation accuracy.

How language models memorize training data, methods for measuring extractable memorization, PII risks in web-scale corpora, and practical privacy mitigations.

Explains how position bias, verbosity bias, and sycophancy distort LLM evaluation. Measure swap consistency, detect length effects.

How RETRO trains language models with retrieval from scratch, using chunked cross-attention to integrate a 2T-token database and cut parameter needs 25x.

Build LLM-as-Judge evaluation pipelines: prompt design, judge model selection, calibration against human annotations, and bias mitigation.

Process reward models score individual reasoning steps instead of final answers alone. Covers training data, credit assignment, math tasks, and limitations.

Explains how Constitutional AI trains safer LLMs using constitutional principles, AI-driven critique and revision, and RLAIF preference labeling.

Evaluate language models with pairwise comparisons and Elo ratings, including preference aggregation, confidence intervals, bias, and significance tests.

Covers chance-corrected agreement metrics for NLP annotation reliability. Calculate Cohen's kappa, Fleiss' kappa, and Krippendorff's alpha with Python examples.

Examines o1-style reasoning models, test-time compute scaling, process reward models, and open research questions shaping the frontier of AI reasoning.

Design rigorous human evaluations for language models. Topics include interface design, annotation paradigms, annotator selection.

Covers benchmark saturation in AI evaluation. Explains why static metrics hit ceiling effects, lose statistical power, and how dynamic benchmarks solve this.

Examines systematic reasoning failures in LLMs including spurious correlations, reasoning shortcuts, negation failures.

Explains how benchmark contamination affects LLM evaluation accuracy. Topics include detection methods including n-gram matching, MinHash.

Explains how LLMs solve math problems, from grade-school word problems to competition math. Topics include chain-of-thought, process reward models, GRPO.

Explains how TruthfulQA tests AI truthfulness by identifying imitative falsehoods.

Explains how process reward models score each reasoning step, how verification-guided search selects correct chains.

Explains how self-consistency, tree of thought, least-to-most prompting, and decomposition strategies improve language model reasoning accuracy and reliability.

Examines the MBPP benchmark for Python code generation evaluation. Topics include crowd-sourced programming tasks, pass@k metrics, execution-based testing.

Explains how chain-of-thought prompting enables language models to reason step by step. Topics include few-shot CoT, zero-shot CoT, self-consistency.

Explains how HumanEval evaluates LLM code generation using functional correctness and the pass@k metric.

Examines LLM text generation for content creation, writing assistance, and code. Topics include quality dimensions, constraint verification, prompt design.

Examines deductive, inductive, abductive, and causal reasoning in LLMs, including how transformers support inference chains and where reasoning breaks down.

GSM8K tests grade-school mathematical reasoning with multi-step word problems. Covers dataset structure, answer scoring, and known benchmark limitations.

Build intelligent dialogue systems with LLMs, covering conversation management, slot filling, memory strategies, and chatbot evaluation techniques.

Apply model merging to combine task fine-tunes, blend styles, compose capabilities, and evaluate merged models using normalized scores and Pareto analysis.

HellaSwag evaluates physical commonsense reasoning with adversarial filtering designed to remove superficial cues and annotation artifacts.

Combine pre-trained models into one without retraining. Topics include weight averaging, task arithmetic, TIES sign-election merging, and DARE random pruning.

MMLU tests language models across 57 subjects from STEM to law. Topics include evaluation protocols, few-shot methods.

Explains how structured pruning removes entire attention heads, transformer layers, and feed-forward neurons to create smaller, faster models.

Explains how weight pruning reduces neural network size by removing redundant parameters.

Covers calibration in machine learning and how model confidence aligns with actual accuracy. Examines ECE, temperature scaling.

Explains how feature distillation, attention transfer, progressive distillation, and on-policy distillation extend knowledge distillation beyond soft labels.

Use Exact Match and token-level F1 to score NLP and question-answering systems, with normalization, partial credit, thresholds, and common scoring errors.

Build multi-layer guardrail systems for LLM applications, covering input validation, output safety, PII detection, topic enforcement.

Explains how differential privacy protects training data in language models, from the mathematical guarantee to DP-SGD, privacy budgets.

BERTScore evaluates text generation using contextual embeddings to measure semantic similarity.

Explains how knowledge distillation transfers a large teacher model's learned knowledge to a smaller student through soft label supervision.

Measure and communicate LLM confidence through calibration, verbalized uncertainty, semantic entropy, and trust-calibrated user interfaces.

Covers ROUGE metrics for summarization evaluation. Topics include ROUGE-N, ROUGE-L, and ROUGE-W, and how they differ from BLEU in assessing text quality.

Covers continual learning evaluation with forward transfer, backward transfer, forgetting metrics.

Examines architecture-based continual learning: progressive networks, PackNet, HAT masks, PathNet.

Explains how experience replay buffers, pseudo-rehearsal, and generative replay prevent catastrophic forgetting in continual learning systems.

Explains how transformer models power sentiment analysis, topic classification, and intent detection.

Explains how the BLEU score evaluates machine translation quality using modified n-gram precision and brevity penalties.

Explains how classification-based and rule-based content filters protect language model deployments.

Explains how Elastic Weight Consolidation and Synaptic Intelligence protect critical parameters to prevent catastrophic forgetting in continual learning.

Covers cross-entropy loss for language models. Topics include entropy, KL divergence, perplexity.

Design reliable LLM evaluations with representative test sets, suitable metrics, and controls for contamination, overfitting, and misleading averages.

Perplexity measures how well a language model predicts tokens. Covers cross-entropy, tokenization effects, vocabulary size, and fair model comparisons.

Examines neural text-to-speech systems from acoustic modeling to vocoding. Topics include Tacotron, FastSpeech.

Covers the continual learning problem, why neural networks catastrophically forget sequential tasks, and the three canonical learning scenarios.

Explains how modern AI systems integrate speech with large language models. Examines audio tokenization, neural codecs.

Whisper was trained on 680,000 hours of weakly supervised audio. Covers data filtering, multilingual objectives, scaling choices, and zero-shot transfer.

OpenAI Whisper's encoder-decoder architecture enables multilingual speech recognition. Explains how multitask training and special tokens unify transcription.

Explains how sparse autoencoders decompose language model activations into interpretable features using overcomplete dictionaries, sparsity constraints.

Explains how language models link generated claims to source documents, evaluate citation accuracy with NLI, and measure attribution precision and recall.

Explains how speech recognition systems transform raw audio waveforms into mel spectrograms using STFT, mel filterbanks.

Covers LLM cost management with token-based cost modeling, optimization techniques like caching and quantization, cost allocation.

Covers multimodal AI evaluation with VQA benchmarks, image captioning metrics (BLEU, CIDEr, CLIPScore), and text-to-image quality (FID).

Monitor LLM output quality in production: track BLEU, BERTScore, and semantic metrics, detect drift with KS tests and CUSUM, catch regressions with A/B testing.

Monitor production LLM systems with metrics collection, structured logging, dashboard design, alerting rules, and concept drift detection.

Explains how multimodal models use image-text pairs, interleaved documents, and visual instruction data.

Flamingo adds visual input to frozen language models with a Perceiver Resampler and gated cross-attention. Covers its architecture and training design.

Explains how the logit lens projects transformer hidden states into vocabulary space to reveal how predictions evolve.

LLaVA connects a frozen vision encoder to a language model through a projection layer. Covers visual instruction tuning, architecture, data, and evaluation.

Extract attention weights from transformer models, visualize head patterns, measure head entropy, and understand the key caveats.

Covers LLM caching strategies including prompt caching with KV reuse, semantic caching with embedding similarity, cache invalidation policies.

Route LLM requests intelligently across model tiers using rule-based, difficulty-based, and cascade strategies, plus A/B testing to validate routing decisions.

Auto-scale LLM serving infrastructure using GPU utilization, queue depth, and TTFT metrics. Topics include horizontal vs vertical scaling.

Explains how projection layers bridge vision encoders and LLMs. Topics include linear transformation, MLP projection.

Explains how vision encoders bridge pixels and language in multimodal AI systems. Examines SigLIP training objectives, high-resolution handling strategies.

Explains how CLIP enables zero-shot classification by connecting vision and language. Examines dual-encoder architecture, contrastive learning.

Explains how Vision Transformers work: from image patching and embeddings to self-attention. Topics include ViT architecture, inductive biases.

Covers LLM throughput optimization with continuous batching, batch size tuning, parallelism strategies, and measuring tokens-per-second under real workloads.

Covers LLM serving latency from TTFT to TPOT. Topics include KV cache management, continuous batching, speculative decoding, streaming responses.

Serve language models in production: weight loading strategies, tensor parallelism, request batching, rate limiting.

Evaluate AI agents with task completion metrics, trajectory analysis, and safety testing. Topics include WebArena, SWE-bench, GAIA, and OSWorld benchmarks.

Explains how AI agents manage short-term context and long-term memory. Examines vector databases, retrieval algorithms.

Explains how layer probing maps linguistic properties across BERT layers, from surface features in lower layers to semantic content in upper layers.

Measure code LLM quality using execution-based evaluation, the pass@k metric, and key benchmarks like HumanEval, APPS, and SWE-bench.

Explains how LLM agents safely execute generated code using sandboxed environments, capture execution feedback.

Covers LLM tool selection through embedding-based routing, hybrid strategies, and semantic interfaces. Build scalable multi-tool agent systems.

Covers LLM agent architectures including control loops, state management strategies, planning mechanisms, and termination conditions for autonomous AI systems.

Transform raw text into structured data using named entity recognition, relation extraction, event extraction, and LLM-based JSON output generation.

Explains how the ReAct pattern enables LLM agents to interleave reasoning with tool execution.

Covers code generation with LLMs, covering docstring-to-code, test-driven generation, sampling strategies, self-repair loops, and generation quality metrics.

Explains how LLM-powered code completion works: context assembly with fill-in-the-middle, candidate ranking, latency optimizations like speculative decoding.

Explains why interpretability matters for language models, covering debugging, trust, safety alignment, scientific understanding.

Language models can explain code, detect bugs, support review, and run semantic code search. Covers dual encoders, contrastive training, and evaluation.

Explains how function calling enables LLMs to invoke external tools and APIs through structured JSON schemas, bridging natural language and executable code.

Explains why LLMs require external tools to overcome knowledge cutoffs, computational limits, and hallucinations. Topics include tool-augmented AI systems.

Covers RAG prompt engineering with strategic context placement, citation formats, and truncation strategies to improve LLM accuracy and reduce hallucinations.

Explains how reranking with cross-encoders solves bi-encoder limitations. Topics include two-stage retrieval, training strategies.

Explains how red teams systematically probe language models for safety failures, covering attack taxonomies, ASR metrics, RL-based automated attack generation.

Covers direct and indirect prompt injection attacks, how RAG pipelines create injection surfaces, and the layered defense strategies used to mitigate them.

Explains how code language models are trained: code data curation, code-specific tokenization, fill-in-the-middle objectives.

Hybrid search combines BM25 keyword ranking with dense vector retrieval. Covers reciprocal rank fusion, weighted scores, recall, and tuning tradeoffs.

Covers systematic strategies for hyperparameter search, how muP enables transfer across model scales.

Explains how steering vectors and activation addition let you modify language model behavior at inference time.

Explains how Product Quantization compresses embeddings up to 100x using learned codebooks and asymmetric distance computation for scalable vector search.

Detect and prevent training instability in deep learning. Topics include loss spikes, gradient norm monitoring, gradient clipping.

Explains how gradient accumulation simulates large batch sizes on limited GPU memory by splitting batches into micro-batches.

Explains how weight decay regularizes neural networks, why AdamW decouples weight decay from adaptive gradients.

Explains how batch size affects gradient noise and generalization, apply the linear scaling rule for learning rates, identify the critical batch size.

Covers IVF indexes for scalable vector search. Topics include clustering-based partitioning, nprobe tuning, and IVF-PQ compression for billion-scale retrieval.

Examines harmful content categories, misuse scenarios, unintended harms, and structured threat models for reasoning about safety in language AI systems.

Covers cosine learning rate schedule used in GPT and LLaMA training: the decay formula, warm restarts, key parameters, and comparison with linear decay.

Covers Hierarchical Navigable Small World (HNSW) graphs for vector search. Topics include graph architecture, construction, and tuning for high-speed retrieval.

Covers question answering systems from span extraction with BERT to retrieval-augmented generation, covering evaluation metrics and open-domain QA pipelines.

Examines vector similarity search for RAG systems. Compare cosine, dot product, and Euclidean metrics, and implement exact vs. approximate search with FAISS.

Explains how learning rate schedules improve neural network training. Topics include step decay, exponential decay, inverse square root with warmup.

Explains how embedding models convert text to vectors for RAG. Topics include bi-encoder architecture, pooling strategies, dimensionality trade-offs.

Covers document chunking for RAG systems. Examines fixed-size, recursive, and semantic strategies to balance retrieval precision with context window limits.

Save and restore complete training state, choose checkpoint frequency, implement asynchronous I/O, and recover distributed LLM training runs from failures.

Covers contrastive learning for dense retrieval. Train models using InfoNCE loss, in-batch negatives, and hard negative mining strategies effectively.

Covers distributed training communication: gradient compression, topology-aware all-reduce, NCCL tuning.

Explains how mixed precision training uses FP16 and BF16 floating point formats to speed up LLM training and cut memory usage without sacrificing accuracy.

Covers dense retrieval for semantic search. Examines bi-encoder architectures, embedding metrics, and contrastive learning to overcome keyword limitations.

How activation checkpointing trades compute for memory by discarding and recomputing activations.

Explains how FSDP shards model parameters, gradients, and optimizer states across GPUs to train billion-parameter models.

Explains how ZeRO eliminates memory redundancy in distributed training by partitioning optimizer states, gradients, and parameters.

Covers RAG system design by exploring retriever-generator interactions, timing strategies like iterative retrieval, and architectural variations like RETRO.

Explains why LLMs need Retrieval-Augmented Generation. Explains how RAG bridges knowledge gaps, reduces hallucinations, and enables non-parametric memory.

Explains how pipeline parallelism splits deep models across devices, manages bubble overhead with micro-batching, and compares GPipe vs 1F1B schedules.

Covers extractive and abstractive summarization, from TextRank and MMR to BART and LLMs, with ROUGE and BERTScore evaluation techniques.

Explains how tensor parallelism splits weight matrices across GPUs using column and row strategies, enabling training of models too large for any single device.

Covers LLM inference serving architecture, token-aware load balancing, and auto-scaling. Optimize time-to-first-token and throughput for production systems.

Explains how continuous batching achieves 2-3x throughput gains in LLM inference through iteration-level scheduling, eliminating static batch inefficiencies.

Covers the mathematical framework for speculative decoding, including the exact acceptance criterion, rejection sampling logic.

Explains how activation patching locates where information flows in transformers through causal tracing, path patching, and component attribution experiments.

Explains how DDP trains large models across multiple GPUs using ring all-reduce gradient synchronization, gradient bucketing.

Speculative decoding uses a smaller draft model to propose tokens that a larger model verifies in parallel, reducing latency without changing output quality.

Explains how GPU memory breaks down into parameters, gradients, optimizer states, and activations. Estimate memory requirements and debug out-of-memory errors.

Covers GGUF format for storing quantized LLMs. Topics include file structure, quantization types, llama.cpp integration.

Explains how language models power creative writing, poetry generation, storytelling, and the ethical questions of authorship and originality in generative AI.

Covers GPU memory hierarchy, CUDA cores, Tensor Core throughput, and how to read GPU specs to optimize training workloads and debug performance bottlenecks.

Explains how Activation-aware Weight Quantization protects salient weights to compress LLMs. Topics include the algorithm, scaling factors.

Explains how adversarial prompts bypass LLM safety training, covering roleplay attacks, GCG gradient-based suffixes, PAIR automation.

Interpret sparse autoencoder features through activation patterns, automated naming, monosemanticity measurement, and causal feature circuit analysis.

Explains how GPTQ optimizes weight quantization using Hessian-based error compensation to compress LLMs to 4 bits while maintaining near-FP16 accuracy.

Explains how LLMs are trained on synthetic data, from Self-Instruct and Evol-Instruct to quality verification, diversity control, and knowledge distillation.

Covers INT4 quantization techniques for LLMs. Topics include group-wise quantization, NF4 format, double quantization.

Construct effective pretraining data recipes by setting domain proportions, applying quality weighting, running proxy experiments.

Covers INT8 weight quantization with absmax and smooth quantization techniques. Solve the outlier problem in large language models.

Detect and remove personal information from LLM training data with regex, named entity recognition, and hybrid privacy pipelines.

Explains how toxicity classifiers work, how to calibrate thresholds for pretraining data.

Filter low-quality text from web corpora using heuristic rules, perplexity scoring, and classifier-based methods with tunable thresholds.

Explains how weight quantization maps floating-point values to integers, reducing LLM memory by 4x. Topics include scale, zero-point.

Explains how MinHash compresses documents into compact signatures that estimate Jaccard similarity, enabling near-duplicate detection.

Explains how language identification works in NLP pipelines. Topics include n-gram models, FastText LID, code-switching, confidence thresholds.

Extract clean text from HTML and PDFs for LLM training data. Topics include boilerplate removal, text density algorithms, Trafilatura.

Covers KV cache compression techniques including eviction strategies, attention sinks, the H2O algorithm, and INT8 quantization for efficient LLM inference.

Explains how web crawlers discover and download internet content at scale, covering Common Crawl architecture, robots.txt compliance, politeness policies.

Benchmark scores can mislead when test data leaks, metrics saturate, or systems game proxies. Covers contamination, brittleness, Goodhart's Law, and mitigation.

Explains how PagedAttention uses virtual memory paging to eliminate KV cache fragmentation, enabling 5x better memory utilization in LLM serving systems.

Build rigorous NLP benchmarks: task definition, dataset collection, annotation guidelines, inter-annotator agreement, contamination detection.

Calculate KV cache memory requirements for transformer models. Topics include batch size, context length, GQA optimization, and GPU deployment planning.

Explains how KV cache eliminates redundant attention computations in transformers. Topics include memory requirements, cache structure.

Explains how multimodal AI powers document understanding, medical imaging diagnostics, video analysis, and complex reasoning tasks across real-world domains.

Covers iterative alignment for LLMs with online DPO, rolling references, Constitutional AI, and SPIN. Build self-improving models beyond single-shot training.

Covers diffusion models from the DDPM objective to latent diffusion, classifier-free guidance, image editing techniques, ControlNet, and FID evaluation metrics.

Covers RLAIF and Constitutional AI for scalable model alignment. Use AI feedback, design constitutions, and train reward models effectively.

Covers four core image understanding tasks: visual question answering, image captioning, visual grounding, and scene understanding.

Why attention weights fail as explanations, how manipulation studies expose their limits, and what gradient-based methods offer as more faithful alternatives.

Multimodal models align text, images, and other inputs in shared embedding spaces. Covers contrastive loss, dual encoders, joint encoders, and tradeoffs.

Build safe autonomous agents using action constraints, sandboxing, real-time monitoring, prompt injection defenses, and human-in-the-loop intervention patterns.

Explains how multi-agent AI systems coordinate through topologies, communication protocols, role assignment.

DPO variants include IPO, KTO, ORPO, and cDPO. Compare their objectives, data requirements, computational costs, and suitable alignment tasks.

Implement Direct Preference Optimization in PyTorch. Topics include preference data formatting, loss computation, training loops.

Explains how LLM agents plan, decompose tasks, execute multi-step goals, and recover from failures using architectures like ReWOO, Tree-of-Thought.

Derive the DPO loss function from first principles. Explains how the optimal RLHF policy leads to reward reparameterization and direct preference optimization.

Explains how DPO eliminates reward models from LLM alignment. Topics include the reward-policy duality that enables supervised preference learning.

Explains how KL divergence prevents reward hacking in RLHF by keeping policies close to reference models.

Covers RLHF pipeline with three stages: Supervised Fine-Tuning, Reward Model training, and PPO optimization. Topics include debugging techniques.

Explains how PPO applies to language models. Topics include policy mapping, token action spaces, KL divergence penalties, and advantage estimation for RLHF.

Covers PPO's clipped objective for stable policy updates. Topics include trust regions, GAE advantage estimation.

Covers policy gradient theory for language model alignment. Topics include REINFORCE algorithm, variance reduction with baselines, and foundations for PPO.

Examines reward hacking in RLHF where language models exploit proxy objectives. Topics include distribution shift, over-optimization, and mitigation strategies.

Build neural networks that learn human preferences from pairwise comparisons. Topics include reward model architecture, Bradley-Terry loss.

Explains how the Bradley-Terry model converts pairwise preferences into consistent rankings. Foundation for reward modeling in RLHF and Elo rating systems.

Collect and process human preference data for RLHF. Topics include pairwise comparisons, annotator guidelines, quality metrics, and interface design.

Examines the AI alignment problem and HHH framework. Explains why training language models to be helpful, harmless, and honest presents fundamental challenges.

Evaluate instruction-tuned LLMs using benchmarks like Alpaca Eval and MT-Bench, human evaluation protocols, and LLM-as-Judge automatic methods.

Covers instruction tuning training with data mixing strategies, loss masking, and hyperparameter selection for effective language model fine-tuning.

Explains how chat templates, prompt formats, and role definitions structure conversations for language model instruction tuning and reliable inference.

Explains how Self-Instruct enables language models to generate their own training data through iterative bootstrapping from minimal human-written seed tasks.

Covers practical techniques for creating instruction-tuning datasets. Topics include human annotation, template-based generation, seed expansion.

Explains how instruction tuning transforms base language models into helpful assistants. Examines format design, data diversity, and quality principles.

Compare LoRA, QLoRA, Adapters, IA³, Prefix Tuning, and Prompt Tuning across efficiency, performance, and memory. Practical guide for choosing PEFT methods.

Explains how adapter layers insert trainable bottleneck modules into transformers for parameter-efficient fine-tuning.

Covers prompt tuning for efficient LLM adaptation. Prepend trainable soft prompts to inputs while keeping models frozen. Scales to match full fine-tuning.

Explains how prefix tuning adapts transformers by prepending learnable virtual tokens to attention keys and values. A parameter-efficient fine-tuning method.

Explains how IA3 adapts large language models by rescaling activations with minimal parameters. Compare IA3 vs LoRA for efficient fine-tuning strategies.

Explains how AdaLoRA dynamically allocates rank budgets across weight matrices using SVD parameterization and importance scoring for efficient model adaptation.

Covers QLoRA for fine-tuning large language models on consumer GPUs. Topics include NF4 quantization, double quantization.

Covers LoRA hyperparameter selection for efficient fine-tuning. Topics include rank, alpha, target modules.

Implement LoRA adapters in PyTorch from scratch. Build modules, inject into transformers, merge weights, and use HuggingFace PEFT for production.

Covers LoRA's mathematical foundations including low-rank decomposition, gradient computation, rank selection.

Explains how LoRA reduces fine-tuning parameters by 100-1000x through low-rank matrix decomposition.

Explains why PEFT is essential for LLMs. Analyze storage costs, training memory requirements, and how adapter swapping enables efficient multi-task deployment.

Covers few-shot fine-tuning techniques for language models. Topics include PET, SetFit, and data augmentation to achieve strong results.

Covers learning rate strategies for fine-tuning transformers. Topics include discriminative fine-tuning, layer-wise decay, warmup schedules, and decay methods.

Why neural networks lose earlier capabilities during fine-tuning, with mitigation methods including EWC, L2-SP regularization, replay, and adapters.

Covers full fine-tuning of pre-trained models. Topics include optimal learning rates, batch sizes, warmup schedules, and gradient accumulation techniques.

Explains how transfer learning enables pre-trained models to adapt to new NLP tasks. Topics include pre-training, fine-tuning, layer representations.

Explains how Switch Transformer simplifies MoE with top-1 routing, capacity factors, and training stability for trillion-parameter language models.

Explains how expert parallelism distributes MoE experts across devices using all-to-all communication, enabling efficient training of trillion-parameter models.

Explains how z-loss stabilizes Mixture of Experts training by penalizing large router logits. Topics include formulation, coefficient tuning.

Explains how auxiliary balancing loss prevents expert collapse in MoE models. Topics include loss formulations, coefficient tuning, and PyTorch implementation.

Explains how load balancing prevents expert collapse in Mixture of Experts models. Examines token fractions, load metrics.

Explains how top-K routing selects experts in MoE architectures. Topics include top-1 vs top-2 trade-offs, implementation details.

Examines gating networks in MoE architectures. Topics include router design, softmax gating, Top-K selection, training dynamics.

Explains how expert networks power Mixture of Experts models. Examines FFN-based experts, capacity factors, expert counts, and transformer placement strategies.

Explains how sparse models decouple capacity from compute using conditional computation and mixture of experts to achieve efficient scaling.

Examines grokking: how neural networks suddenly generalize long after memorization. Topics include phase transitions, theories, and training implications.

Explains why larger language models sometimes perform worse on specific tasks. Topics include distractor tasks, sycophancy, and U-shaped scaling patterns.

Examines whether LLM emergent capabilities are genuine phase transitions or measurement artifacts.

Explains how chain-of-thought reasoning emerges in large language models. Topics include CoT prompting techniques, scaling behavior.

Explains how in-context learning emerges in large language models. Topics include scale thresholds, ICL vs fine-tuning, induction heads, and meta-learning.

Explains how LLMs suddenly acquire capabilities through emergence. Topics include phase transitions, scaling behaviors, and the ongoing metric artifact debate.

Transform scaling laws into predictive tools for AI development. Topics include loss extrapolation, capability forecasting.

Chinchilla-optimal training can be inefficient for deployment. Covers deliberate over-training, inference workloads, and total cost modeling for LLM systems.

Examines data-constrained scaling for LLMs: repetition penalties, modified Chinchilla laws, synthetic data strategies, and optimal compute allocation.

Explains how DeepMind's Chinchilla scaling laws changed LLM training by proving models should use 20 tokens per parameter for compute-optimal performance.

Explains how power laws govern neural network scaling. Topics include log-log analysis, fitting techniques, and how to predict model performance at any scale.

Explains how mT5 extends T5 to 101 languages using temperature-based sampling, the mC4 corpus, and 250K vocabulary for effective cross-lingual transfer.

Covers BART's denoising pre-training approach including text infilling, token masking, sentence permutation, and how corruption schemes enable generation.

Explains how T5 reformulates all NLP tasks as text-to-text problems. Topics include task prefixes, classification, NER.

Covers compute-optimal LLM training using Chinchilla scaling laws. Topics include the 20:1 token ratio, practical allocation formulas.

Explains how T5 uses span corruption for pre-training. Topics include sentinel tokens, geometric span sampling, the C4 corpus.

Covers T5's encoder-decoder architecture, relative position biases, span corruption pretraining, and text-to-text framework for unified NLP tasks.

Covers LLaMA's architectural choices including RMSNorm, SwiGLU, and RoPE, plus training data strategies.

Examines Qwen's architectural innovations including GQA, SwiGLU activation, and multilingual tokenization.

Explains how the unigram LM tokenizer trains via the EM algorithm, uses Viterbi decoding for segmentation, and enables subword regularization.

Examines Mistral 7B's architectural innovations including sliding window attention, grouped query attention, and rolling buffer KV cache.

Covers GQA, the attention mechanism behind LLaMA 2 and Mistral. Topics include KV head sharing, memory savings, implementation, and quality tradeoffs.

Explains how Multi-Query Attention reduces KV cache memory by sharing keys and values across attention heads, enabling efficient long-context inference.

Explains why traditional word-level approaches fail with diverse text, from OOV words to morphological complexity.

Examines Microsoft's Phi model family and how textbook-quality training data enables small models to match larger competitors.

Explains how WordPiece differs from BPE by using a likelihood objective for merges. Topics include the PMI score, greedy tokenization, ## prefix notation.

Examines LLaMA's core architectural components: pre-norm with RMSNorm for stable training, SwiGLU feed-forward networks for expressive computation.

Repetition, frequency, and presence penalties alter token probabilities to reduce loops. Covers n-gram blocking, tuning, and effects on generated text.

Constrained decoding uses token masks and grammars to produce valid JSON, SQL, and regular-expression matches from language models.

Covers mechanics of autoregressive generation in transformers, including the generation loop, KV caching for efficiency, stopping criteria.

Explains how nucleus sampling dynamically selects tokens based on cumulative probability, solving top-k limitations for coherent and creative text generation.

Top-k sampling limits each generation step to the k most probable tokens. Covers probability renormalization, diversity, failure modes, and tuning.

Explains how large language models learn new tasks from prompt demonstrations without weight updates.

Explains how temperature scaling reshapes probability distributions during text generation, with mathematical foundations, implementation details.

Explains how ELECTRA achieves BERT-level performance with 1/4 the compute by detecting replaced tokens instead of predicting masked ones.

Examines GPT-2's architecture, model sizes, WebText training, and zero-shot capabilities that changed language modeling through scale.

Covers BERT fine-tuning for downstream NLP tasks. Topics include task-specific heads, hyperparameter tuning, and strategies to prevent catastrophic forgetting.

GPT-1 paired generative pretraining with task-specific fine-tuning. Covers its architecture, objective, benchmark results, and role in transfer learning.

Examines GPT-3's 175B parameter architecture, the emergence of few-shot learning, in-context learning mechanisms.

Covers DeBERTa's disentangled attention mechanism that separates content and position representations.

Covers BERT pre-training covering masked language modeling, next sentence prediction, data preparation, hyperparameters.

Explains how ALBERT reduces BERT's size by 18x using factorized embeddings and cross-layer parameter sharing while maintaining competitive performance.

Explains how RoBERTa surpassed BERT using the same architecture by removing Next Sentence Prediction, implementing dynamic masking.

Examines the BERT architecture in detail covering model sizes (Base vs Large), three-layer embedding system, bidirectional attention patterns.

Covers BERT representation extraction with [CLS] token usage, layer selection strategies, pooling methods, and the frozen vs fine-tuned trade-off.

Covers prefix LM, the hybrid pretraining objective that enables bidirectional prefix understanding with autoregressive generation.

Explains how BART trains language models using diverse text corruptions including token deletion, shuffling, sentence permutation.

Explains how replaced token detection trains language models 4x more efficiently than masked language modeling.

Explains how span corruption works in T5, including span selection strategies, geometric distributions, sentinel tokens.

Explains how Whole Word Masking improves BERT pre-training by masking complete words instead of subword tokens.

Explains how masked language modeling enables bidirectional context understanding. Topics include the MLM objective, 15% masking rate, 80-10-10 strategy.

Explains how memory-augmented transformers extend context beyond attention limits using external key-value stores, retrieval mechanisms.

Explains how causal language modeling trains AI to predict the next token. Topics include autoregressive factorization, cross-entropy loss, causal masking.

Explains how Transformer-XL uses segment-level recurrence to extend effective context length.

Explains how Position Interpolation extends transformer context windows by scaling position indices to stay within training distributions.

Examines the fundamental barriers limiting transformer context windows, including quadratic memory scaling, position encoding extrapolation failures.

Explains why the first tokens in transformer sequences absorb excess attention weight, how this causes streaming inference failures.

NTK-aware scaling extends transformer context windows by adjusting rotary frequencies. Covers position preservation, longer sequences, and tradeoffs.

Covers FlashAttention's tiled computation and online softmax algorithms. Topics include GPU memory hierarchy, CUDA kernel basics.

Explains how FlashAttention achieves 2-4x speedups by restructuring attention computation. Topics include GPU memory hierarchy, tiling for SRAM.

Explains how YaRN extends LLM context length through wavelength-based frequency interpolation and attention temperature correction.

Explains how linear attention achieves O(nd²) complexity by replacing softmax with kernel functions.

Explains how sliding window attention reduces transformer complexity from quadratic to linear.

Explains how Longformer combines sliding window and global attention to process documents of 4,096+ tokens with O(n) complexity instead of O(n²).

Implement sparse attention patterns including local windows, strided attention, and block-sparse methods.

BigBird combines sliding-window, global, and random attention to reach linear complexity. Covers its guarantees and use with long documents.

Global tokens create communication hubs in sparse attention, reducing path length and helping efficient transformers exchange information across long documents.

Explains why self-attention has O(n²) complexity, how memory and compute scale quadratically with sequence length.

Covers encoder-decoder transformer architecture that powers T5 and machine translation. Topics include cross-attention mechanism.

Covers decoder-only transformers powering GPT, Llama, and modern LLMs. Topics include causal masking, autoregressive generation, KV caching.

Design transformer architectures by understanding the key hyperparameters: model depth, width, attention heads, and FFN dimensions.

Covers cross-attention, the mechanism that bridges encoder and decoder in sequence-to-sequence transformers.

Explains how weight tying reduces transformer parameters by sharing the input embedding and output projection matrices.

Explains how encoder-only transformers like BERT use bidirectional self-attention for text understanding.

Explains how GLUs transform feed-forward networks through multiplicative gating. Topics include SwiGLU, GeGLU, and the parameter trade-offs that power LLaMA.

Compare activation functions in transformer feed-forward networks: ReLU's simplicity and dead neuron problem, GELU's smooth probabilistic gating for BERT.

Assemble transformer blocks by combining residual connections, normalization, attention, and feed-forward networks.

Explains how layer normalization enables stable transformer training by normalizing.

Explains how feed-forward networks provide nonlinearity in transformers, with 2-layer architecture, 4x dimension expansion, parameter analysis.

Compare pre-norm and post-norm transformer blocks. Covers layer-normalization placement, gradient flow, training stability, and model depth.

Explains how residual connections solve the vanishing gradient problem in deep networks. Topics include the math behind skip connections, gradient highways.

Covers RMSNorm, the simpler alternative to LayerNorm used in LLaMA, Mistral, and modern LLMs.

Covers sinusoidal position encoding, the deterministic method that gives transformers positional awareness.

Explains why self-attention is blind to word order and what properties positional encodings need.

Explains how RoPE encodes position through vector rotation, making attention scores depend on relative position.

Explains how QKV projections enable transformers to learn flexible attention patterns through specialized query, key, and value representations.

Compare transformer position encoding methods including sinusoidal, learned embeddings, RoPE, and ALiBi.

Explains how relative position encoding improves transformer generalization by encoding token distances rather than absolute positions.

How GPT and BERT encode position through learnable parameters. Topics include embedding tables, position similarity, interpolation techniques.

Explains how ALiBi encodes position through linear attention biases instead of embeddings. Topics include head-specific slopes, extrapolation properties.

Explains how multi-head attention runs multiple attention operations in parallel, enabling transformers to capture diverse relationships like syntax, semantics.

Self-attention has O(n²d) compute and quadratic memory growth. Covers when sparse, linear, and other efficient attention variants reduce those costs.

Covers scaled dot-product attention: how queries and keys compute similarity, why dividing by sqrt(d_k) prevents softmax saturation.

Covers attention masking techniques including padding masks, causal masks, and sparse patterns.

Self-attention relates every token to every other token in a sequence. Covers queries, keys, values, contextual embeddings, masking, and computational cost.

Explains how beam search balances quality and compute in sequence generation, covering greedy decoding limits, length normalization, diverse beam search.

Teacher forcing trains sequence-to-sequence models with ground-truth context. Covers exposure bias, scheduled sampling, and alternatives based on REINFORCE.

Explains how bidirectional LSTMs and GRUs provide full-sequence context by processing text forward and backward, enabling strong sequence labeling.

Explains how Bahdanau attention solves the encoder-decoder bottleneck with dynamic context vectors, softmax alignment.

Examines Luong attention variants including dot product, general, and concat scoring. Topics include global vs local attention, input-feeding.

Explains how copy mechanisms enable seq2seq models to handle out-of-vocabulary words.

Explains how attention mechanisms solve the encoder-decoder bottleneck through soft lookup, alignment scores, and dynamic context vectors built step by step.

Covers the encoder-decoder framework for sequence-to-sequence learning. Topics include context vectors, teacher forcing, BLEU evaluation.

Gated Recurrent Units use reset and update gates to manage sequence memory. Covers GRU equations, implementation, gradient flow, and comparison with LSTMs.

Stacked RNNs build hierarchical representations across recurrent layers. Covers depth-width tradeoffs, variational dropout, ELMo, and practical depth limits.

How LSTMs solve the vanishing gradient problem through the cell state gradient highway, forget gate modulation, and the residual connection analogy.

Covers LSTM architecture including cell state, gate mechanisms, and information flow. Explains how LSTMs solve vanishing gradients.

Explains how BPTT unrolls RNNs for gradient computation, derives the chain rule through time, and implements truncated BPTT with detach() in PyTorch.

Covers mathematics behind LSTM gates including forget, input, output gates, and cell state updates.

Explains why gradient magnitudes collapse exponentially in RNNs, making long-range dependencies impossible to learn without architectural changes like LSTMs.

Covers RNN architecture from Elman equations to hidden state memory. Topics include parameter sharing, unrolling, sequence modeling patterns.

Covers backpropagation from computational graphs to PyTorch autograd. Topics include chain rule derivation, gradient flow through activations.

Covers chunking (shallow parsing) to identify noun phrases, verb phrases, and prepositional phrases using IOB tagging, regex patterns.

Explains how Hidden Markov Models use transition and emission probabilities to solve sequence labeling tasks like POS tagging, with Python implementation.

Covers CRFs for sequence labeling, from log-linear models to feature functions and the forward algorithm.

Explains how finite-state transducers and neural sequence-to-sequence models perform morphological analysis and generation.

Explains how words decompose into morphemes, why inflection and derivation differ, and how morphology explains NLP sparsity, OOV rates, and tokenizer failures.

Covers neural network loss functions covering MSE, cross-entropy, label smoothing, focal loss, KL divergence, and contrastive losses for NLP tasks.

Covers Conditional Random Field training with the forward-backward algorithm, gradient computation, and L-BFGS optimization for sequence labeling tasks.

Covers SGD for training neural networks: mini-batch updates, learning rate selection, cosine annealing, warmup, Nesterov momentum, and loss landscape geometry.

Explains how MLPs stack layers to solve problems no linear model can. Topics include hidden layers, weight matrices, forward pass, universal approximation.

Covers linear classifiers, from weighted dot products and decision boundary geometry to softmax for multiclass problems, gradient descent training.

Covers dropout regularization: inverted dropout scaling, MC dropout uncertainty, spatial dropout for sequences, and dropout in transformers.

Covers Viterbi algorithm for finding optimal tag sequences in HMMs. Topics include dynamic programming, backpointer tracking, log-space computation.

Explains why weight initialization matters for training neural networks. Topics include Xavier and He initialization, orthogonal init, BERT and GPT schemes.

Covers Adam optimizer: first and second moment estimates, bias correction, adaptive learning rates, hyperparameter tuning.

Momentum smooths gradient updates with a velocity term. Covers Polyak momentum, Nesterov acceleration, damped oscillations, and optimization tradeoffs.

Explains how gradient clipping prevents training instability by capping gradient magnitudes. Topics include clip by value vs clip by norm strategies.

Covers every major activation function from sigmoid to GELU. Topics include saturation, dying ReLU, gradient flow analysis.

Covers AdamW by understanding why L2 regularization and weight decay diverge in adaptive optimizers.

Explains how batch normalization eliminates internal covariate shift by normalizing layer activations.

Explains how special tokens like [CLS], [SEP], [PAD], [MASK], and [UNK] structure transformer inputs, enable classification, handle padding.

Covers where subword tokenizers fail: number fragmentation, code identifier splitting, multilingual fertility gaps, emoji edge cases.

Covers POS tagging from tag sets to statistical taggers. Topics include Penn Treebank, Universal Dependencies, emission and transition probabilities.

Explains how NER identifies people, organizations, and locations using BIO sequence labeling. Topics include entity types, boundary detection, nested entities.

SentencePiece trains BPE and unigram tokenizers directly on raw text. Covers whitespace handling, multilingual vocabularies, and model training.

Train custom tokenizers with HuggingFace, covering corpus preparation, vocabulary sizing, algorithm selection, saving, versioning.

Covers the BIO tagging scheme for named entity recognition, including BIOES variants, span-to-tag conversion, decoding.

Covers Byte Pair Encoding (BPE), the subword tokenization algorithm powering GPT and modern LLMs. Explains how BPE builds a vocabulary.

Explains how GloVe derives word embeddings from co-occurrence ratios, derives the weighted least squares objective.

Explains how FastText extends Word2Vec with character n-grams to handle out-of-vocabulary words, typos.

Evaluate word embeddings using similarity benchmarks, analogy tests, t-SNE visualization, downstream tasks, and bias detection with WEAT.

Covers Word2Vec training pipeline: subsampling, learning rate scheduling, minibatch training, convergence monitoring.

Explains how hierarchical softmax reduces word embedding training from O(V) to O(log V) using Huffman-coded binary trees, path probabilities.

Explains how word embeddings solve analogies via vector arithmetic, covering the parallelogram model, 3CosAdd and 3CosMul methods, evaluation datasets.

Explains how negative sampling reduces Word2Vec training from O(V) to O(k), covering the binary classification objective, unigram^0.75 sampling distribution.

Examines the CBOW Word2Vec architecture covering context averaging, the objective function, gradient derivation, training dynamics.

Explains how the Skip-gram model trains a neural network to predict context words and learns dense word embeddings.

Explains how Singular Value Decomposition compresses sparse co-occurrence matrices into dense word embeddings through Latent Semantic Analysis.

Explains how PMI and PPMI transform raw co-occurrence counts into normalized word association scores.

Examines raw, log-scaled, boolean, augmented, and L2-normalized term frequency variants, with sparsity analysis and efficient computation using scikit-learn.

Explains how Firth's principle that words are known by their company underpins distributional semantics.

Explains how Inverse Document Frequency (IDF) measures word importance across a corpus by weighting rare, discriminative terms higher than common words.

Covers TF-IDF for text representation, including the core formula, variants, normalization, document similarity, feature extraction, sklearn TfidfVectorizer.

Explains how perplexity measures language model quality through cross-entropy and information theory.

Covers BM25, the probabilistic ranking algorithm powering modern search engines. Topics include IDF derivation, term saturation, length normalization, BM25L.

Explains how word-word and word-document co-occurrence matrices encode distributional meaning.

Explains how n-gram language models assign probabilities to word sequences using the chain rule, Markov assumption, and MLE.

Covers smoothing techniques that solve the zero probability problem in n-gram models, from simple add-k smoothing through Good-Turing estimation to Kneser-Ney.

Explains how the Bag of Words model transforms text into numerical vectors through word counting, vocabulary construction, and sparse matrix storage.

Covers sentence boundary detection in NLP, covering the period disambiguation problem, rule-based approaches.

Covers n-gram text representations including bigrams, trigrams, character n-grams, and skip-grams. Topics include extraction techniques.

Split text into words and tokens using whitespace, punctuation handling, and linguistic rules. Topics include NLTK, spaCy, Penn Treebank conventions.

Covers text normalization techniques including Unicode NFC/NFD/NFKC/NFKD forms, case folding vs lowercasing, diacritic removal, and whitespace handling.

Covers regular expressions for text processing, covering metacharacters, quantifiers, lookarounds, and practical NLP patterns.

Covers character encoding fundamentals including ASCII, Unicode, and UTF-8. Detect, fix, and prevent encoding errors like mojibake in your NLP pipelines.

Covers BART's encoder-decoder architecture combining BERT and GPT designs. Examines attention patterns, model configurations, and implementation details.

Covers RAG evaluation with metrics for retrieval quality (Precision@K, NDCG, MRR) and generation faithfulness using the RAGAS framework for AI systems.

Explains how Kaplan scaling laws predict LLM performance from model size, data, and compute.

Examines Mixtral 8x7B's sparse architecture and top-2 expert routing. Explains how MoE models match Llama 2 70B quality.

Deploy your AI agent from a local script to a production service. Topics include packaging, cloud deployment, APIs, and making your agent accessible to users.

Establish ethical guidelines and implement human oversight for AI agents. Topics include defining core principles, encoding ethics in system prompts.

Control AI agent actions with least-privilege permissions, confirmation steps, and sandboxing. Covers tool allowlists, sensitive operations, and safe defaults.

Implement content safety and moderation in AI agents, including system-level instructions, output filtering, pattern blocking, graceful refusals.

Use observability for continuous agent improvement. Topics include patterns in logs, turn observations into targeted improvements, track quantitative metrics.

Read agent logs, trace reasoning chains, identify common problems, and systematically debug AI agents.

Add logging to AI agents to debug behavior, track decisions, and monitor tool usage. Includes practical Python examples.

Create feedback loops that continuously improve your AI agent through real-world usage data, pattern analysis, and targeted improvements.

Create and use test cases to evaluate AI agent performance. Build broad test suites, track results over time.

Define clear, measurable success criteria for AI agents including correctness, reliability, efficiency, safety.

Examines the trade-offs of multi-agent AI systems, from specialization and parallel processing to coordination challenges and complexity management.

Explains how AI agents exchange information and coordinate actions through structured messages, communication patterns like pub-sub and request-response.

Explains how multiple AI agents collaborate through specialization, parallel processing, and coordination.

See how AI agents use planning to handle complex, multi-step tasks. Topics include task decomposition, sequential execution.

Explains how AI agents execute multi-step plans sequentially, handle failures gracefully, and adapt when things go wrong.

Explains how AI agents break down complex goals into manageable subtasks. Topics include task decomposition strategies, sequential vs parallel tasks.

Define what your AI agent can and cannot do through access controls, action policies, rate limits, and scope boundaries.

Explains how AI agents perceive their environment through inputs, tool outputs, and memory.

Explains what an environment means for AI agents, from digital assistants to physical robots. Explains how environment shapes perception, actions.

Explains how AI agents maintain continuity across sessions with ephemeral, session, and persistent state management.

Structure AI agents with clear architecture patterns. Build organized agent loops, decision logic.

Explains what agent state means and why it's essential for building AI agents that can handle complex, multi-step tasks.

Build a complete AI agent memory system combining conversation history and persistent knowledge storage.

Explains how AI agents store and retrieve information across sessions using vector databases, embeddings, and semantic search.

Give AI agents the ability to remember recent conversations, handle follow-up questions, and manage conversation history across multiple interactions.

Build a working calculator tool for your AI agent from scratch. Topics include the complete workflow from Python function to tool integration.

Call language models from Python code, including GPT-5, Claude Sonnet 4.5, and Gemini 2.5. Covers API integration, error handling.

Design effective tool interfaces for AI agents, from basic function definitions to multi-tool orchestration.

Explains why AI agents need external tools to overcome limitations like outdated knowledge, imprecise calculations, and inability to take real-world actions.

Use chain-of-thought prompting to get AI agents to reason through problems step by step, improving accuracy and transparency for complex questions.

Guide AI agents to verify and refine their reasoning through self-checking techniques. Topics include practical methods for catching errors, improving accuracy.

Teach AI agents to think through problems step by step using chain-of-thought reasoning.

Covers art of communicating with AI agents through effective prompting. Craft clear instructions, use roles and examples.

Covers advanced prompting strategies for AI agents including role assignment, few-shot prompting with examples, and iterative refinement.

Covers the fundamentals of writing effective prompts for AI agents. Explains how to be specific, provide context.

Language models are the reasoning core of many AI agents. Covers token prediction, instruction following, tool selection, and limits of model-only systems.

Covers what you'll build throughout this book: a capable AI agent that remembers conversations, uses tools, plans tasks, and grows smarter with each chapter.

Explains how language models predict text, process tokens, and power AI agents through simple analogies and clear explanations.

Explains what distinguishes AI agents from chatbots, exploring perception, reasoning, action, and autonomy.

Covers continuous post-training, including parameter-efficient fine-tuning with LoRA, catastrophic forgetting prevention, incremental model updates.

Covers GPT-4o, including unified multimodal architecture, real-time processing, unified tokenization, advanced attention mechanisms, memory mechanisms.

DeepSeek R1 uses reinforcement learning and distilled reasoning models for mathematical and coding tasks. Covers its training design, results, and limitations.

Covers agentic AI systems introduced in 2024. Explains how AI systems evolved from reactive tools to autonomous agents capable of planning.

AI co-scientist systems generate hypotheses, plan experiments, and synthesize evidence. Covers autonomous research workflows, evaluation, and human oversight.

Covers V-JEPA 2, including vision-based world modeling, joint embedding predictive architecture, visual prediction, embodied AI.

Examines Mistral AI's Mixtral models and how they demonstrated that sparse mixture-of-experts architectures could be production-ready.

Covers specialized large language models for low-resource languages, including synthetic data generation, cross-lingual transfer learning.

Covers Constitutional AI, including principle-based alignment, self-critique training, reinforcement learning from AI feedback (RLAIF), scalability advantages.

Examines multimodal large language models that integrated vision and language capabilities, enabling AI systems to process images and text together.

Covers the 2023 open LLM wave, including MPT, Falcon, Mistral, and other open models. Explains how these models created a competitive ecosystem.

LLaMA showed that carefully trained smaller models could match larger systems. Covers model sizes, data choices, efficiency, and open research access.

Covers GPT-4, including multimodal capabilities, improved reasoning abilities, enhanced safety and alignment, human-level performance on standardized tests.

Covers BIG-bench (Beyond the Imitation Game Benchmark) and MMLU (Massive Multitask Language Understanding), the widely used evaluation benchmarks.

Covers function calling capabilities in language models from 2023, including structured outputs, tool interaction, API integration.

QLoRA combines 4-bit quantization with low-rank adapters to fine-tune large language models on limited hardware while preserving model quality.

Whisper applies encoder-decoder transformers to multilingual speech recognition, translation, and language identification across noisy audio conditions.

Flamingo connects frozen vision and language models through gated cross-attention, supporting few-shot image and video tasks without task-specific fine-tuning.

Covers Google's PaLM, the 540 billion parameter language model that demonstrated advance capabilities in complex reasoning, multilingual understanding.

Covers HELM (Holistic Evaluation of Language Models), the early evaluation framework.

Covers multi-vector retrieval systems introduced in 2021. Explains how token-level contextualized embeddings enabled fine-grained matching.

Chain-of-thought prompting elicits intermediate reasoning steps from language models. Covers zero-shot and few-shot methods, benefits, and limits.

Covers the 2021 Foundation Models Report published by Stanford's CRFM. Explains how this influential report formally defined foundation models.

Covers Mixture of Experts (MoE) architectures, including routing mechanisms, load balancing, emergent specialization.

Covers OpenAI's InstructGPT research from 2022, including the three-stage RLHF training process, supervised fine-tuning, reward modeling.

Covers EleutherAI's The Pile, the early 825GB open-source dataset that broadened access to high-quality training data for large language models.

Covers Dense Passage Retrieval (DPR) and Retrieval-Augmented Generation (RAG), the 2020 innovations.

Covers BLOOM, the BigScience collaboration's 176-billion-parameter open-access multilingual language model released in 2022.

Covers the 2020 scaling laws discovered by Kaplan et al. Explains how power-law relationships predict model performance from scale.

Covers the Chinchilla scaling laws introduced in 2022. Explains how compute-optimal training balances model size and training data.

Stable Diffusion generates images in a compressed latent space. Covers text conditioning, the denoising process, training, inference, and model accessibility.

Covers FlashAttention introduced in 2022. Explains how IO-aware attention computation enabled 2-4x speedup and 5-10x memory reduction.

Covers OpenAI's CLIP, the early vision-language model that enables zero-shot image classification through contrastive learning.

Covers instruction tuning introduced in 2021. Explains how fine-tuning on diverse instruction-response pairs changed language models.

Examines how Mixture of Experts (MoE) architectures changed large language model scaling in 2024.

Covers OpenAI's DALL·E 2, the major text-to-image generation model that combined CLIP-guided diffusion with high-quality image synthesis.

Codex adapted GPT-3 for code completion and generation. Covers its training data, natural-language prompts, benchmark results, and role in developer tools.

Covers OpenAI's DALL·E, the early text-to-image generation model that extended transformer architectures to multimodal tasks.

GPT-3 showed that scaling autoregressive transformers could enable in-context and few-shot learning. Covers its architecture, data, prompting, and limitations.

Covers Google's T5 (Text-to-Text Transfer Transformer) introduced in 2019. Explains how the text-to-text framework unified diverse NLP tasks.

Covers GLUE and SuperGLUE benchmarks introduced in 2018. Explains how these standardized evaluation frameworks changed language AI research.

Transformer-XL extends context with segment recurrence and relative positions. Covers its architecture, efficiency, training method, and influence.

Covers BERT's application to information retrieval in 2019. Explains how transformer architectures changed search and ranking systems.

Covers ELMo and ULMFiT, the advance methods that established transfer learning for NLP in 2018.

Covers OpenAI's GPT-1 and GPT-2 models. Explains how autoregressive pretraining with transformers enabled transfer learning across NLP tasks.

Covers BERT (Bidirectional Encoder Representations from Transformers), including masked language modeling, bidirectional context understanding.

Explains how XLNet, RoBERTa, and ALBERT refined BERT through permutation language modeling, optimized training procedures, and architectural efficiency.

Covers preference-based learning, the framework developed by Christiano et al. in 2017.

Covers the Transformer architecture, including self-attention mechanisms, multi-head attention, positional encodings.

Covers Wikidata, the collaborative multilingual knowledge base launched in 2012. Explains how Wikidata changed structured knowledge representation.

Covers FastText and subword tokenization, including character n-gram embeddings, handling out-of-vocabulary words, morphological processing.

Covers residual connections, the architectural innovation that solved the vanishing gradient problem in deep networks.

Covers Google's transition to neural machine translation in 2016. Explains how GNMT replaced statistical phrase-based methods with end-to-end neural networks.

Covers sequence-to-sequence neural machine translation, the 2014 advance that changed translation from statistical pipelines to end-to-end neural models.

Covers GloVe (Global Vectors) and the Adam optimizer, two early 2014 developments that changed neural language processing.

The application of deep neural networks to speech recognition in 2012, led by Geoffrey Hinton and his colleagues, marked a major advance.

Covers Memory Networks, the 2014 advance that introduced external memory to neural networks.

Covers neural information retrieval, the advance approach that learned semantic representations for queries and documents.

Covers layer normalization, the normalization technique that computes statistics across features for each example.

Covers word2vec, the advance method for learning dense vector representations of words.

Covers SQuAD (Stanford Question Answering Dataset), the benchmark that established reading comprehension as a flagship NLP task.

DeepMind's WaveNet changed text-to-speech synthesis in 2016 by generating raw audio waveforms directly using neural networks.

Examines IBM Watson's historic victory on Jeopardy! in February 2011, examining the system's architecture, multi-hypothesis answer generation.

Freebase introduced a collaborative knowledge graph for representing entities and relationships. Covers its schema, community editing, applications, and legacy.

Covers Latent Dirichlet Allocation (LDA), the advance Bayesian probabilistic model that changed topic modeling.

Examines Yoshua Bengio's early 2003 Neural Probabilistic Language Model that changed NLP by learning dense, continuous word embeddings.

In 2005, the PropBank project at the University of Pennsylvania added semantic role labels to the Penn Treebank.

Traces statistical parsing's major shift from rule-based to data-driven approaches. Explains how Michael Collins's 1997 parser.

How phrase-based translation (2003) extended IBM statistical MT to phrase-level learning, capturing idioms and collocations.

How Maximum Entropy models and Support Vector Machines changed NLP in 1996 by enabling flexible feature integration for sequence labeling, text classification.

In 1998, Charles Fillmore's FrameNet project at ICSI Berkeley released the first large-scale computational resource based on frame semantics.

Examines John Searle's influential 1980 thought experiment challenging strong AI.

Examines William Woods's influential 1970 parsing formalism that extended finite-state machines with registers, recursion, and actions.

Latent Semantic Analysis uses matrix factorization to uncover hidden relationships between terms and documents for retrieval, clustering, and topic discovery.

Conceptual Dependency maps sentences to primitive actions and roles. Covers Roger Schank's theory, semantic equivalence, inference, and question answering.

Andrew Viterbi's 1967 dynamic programming algorithm finds the most likely hidden-state sequence, with applications in HMMs, tagging, and speech recognition.

The 1954 Georgetown-IBM demonstration marked an important moment in computational linguistics.

Covers BM25, the major probabilistic ranking algorithm that changed information retrieval. Explains how BM25 solved TF-IDF's limitations.

Traces Richard Montague's major framework for formal natural language semantics. Explains how Montague Grammar introduced compositionality, intensional logic.

Michael Lesk's 1983 algorithm resolves word senses by comparing dictionary definitions with surrounding context. Covers the method, code, and limitations.

Explains how Gerard Salton's Vector Space Model and TF-IDF weighting changed information retrieval in 1968.

Examines Noam Chomsky's early 1957 work "Syntactic Structures" that changed linguistics, challenged behaviorism.

In 2002, IBM researchers introduced BLEU (Bilingual Evaluation Understudy), revolutionizing machine translation evaluation.

Conditional Random Fields model structured predictions without assuming independent labels. Covers the 2001 paper, feature design, inference, and later uses.

Natural language processing underwent a fundamental shift from symbolic rules to statistical learning.

Claude Shannon's 1948 work on information theory introduced n-gram models, one of the most core concepts in natural language processing.

In 1950, Alan Turing proposed a deceptively simple test for machine intelligence, originally called the Imitation Game.

Joseph Weizenbaum's ELIZA, created in 1966, became the first computer program to hold something resembling a conversation.

Hidden Markov Models changed speech recognition in the 1970s by introducing a clever probabilistic approach.

In 1958, Frank Rosenblatt created the perceptron at Cornell Aeronautical Laboratory, the first artificial neural network.

In 1968, Terry Winograd's SHRDLU system demonstrated a major approach to natural language understanding by grounding language in a simulated blocks world.

Bernard Widrow and Marcian Hoff built MADALINE at Stanford in 1962, taking neural networks beyond the perceptron's limitations.

In 1991, IBM researchers changed machine translation by introducing the first broad statistical approach.

In 1995, RNNs changed sequence processing by introducing neural networks with memory: connections.

Hochreiter and Schmidhuber introduced LSTMs in 1997 to address vanishing gradients. Covers gated memory, long context, and later sequence models.

In the 1980s, neural networks hit a wall: nobody knew how to train deep models. That changed when Rumelhart, Hinton.

In the mid-1990s, Princeton University released WordNet, a major lexical database.

In 1988, Yann LeCun introduced Convolutional Neural Networks at Bell Labs, forever changing how machines process visual information.

In 1987, Slava Katz solved one of statistical language modeling's biggest problems. When your model encounters word sequences it has never seen before.

In 1987, Alex Waibel introduced Time Delay Neural Networks, a major architecture that changed how neural networks process sequential data.

Covers OpenAI's ChatGPT release in 2022, including the conversational interface, RLHF training approach, safety measures.

Covers XLM (Cross-lingual Language Model) introduced by Facebook AI Research in 2019. Explains how cross-lingual pretraining.

Covers long context language models introduced in 2024. Explains how models achieved 1M+ token context windows through efficient attention mechanisms.

In 2004, ROUGE and METEOR addressed critical limitations in BLEU's evaluation approach.

The Penn Treebank established large tagged corpora for statistical NLP, enabling comparable research in part-of-speech tagging and syntactic parsing.

Examines market microstructure mechanics including order book architecture, matching algorithms, and order types.

Covers transaction cost analysis and market impact modeling. Estimate spread, slippage, and liquidity to build realistic backtests and execution strategies.

Covers backtesting frameworks to validate trading strategies. Avoid look-ahead bias, measure risk-adjusted returns.

Covers event-driven trading strategies including merger arbitrage, earnings plays, and fixed income relative value.

Examines cryptocurrency market structure, quantitative strategies for extreme volatility, and risk management in 24/7 decentralized trading.

Extract trading signals from alternative data using NLP. Topics include sentiment analysis, text processing, and building news-based trading systems.

Build ML-driven trading strategies covering return prediction, sentiment analysis, alternative data integration, and reinforcement learning for execution.

Covers supervised ML algorithms for trading: linear models, random forests, gradient boosting.

Explains HFT strategies, including cross-market arbitrage, latency exploitation, electronic market making, and the systems behind microsecond trading.

Explains how market makers capture bid-ask spreads, manage inventory risk, and use the Avellaneda-Stoikov model for quote placement.

Covers volatility as an asset class. Topics include delta hedging, variance swaps, dispersion trading.

Build long-short factor portfolios using quintile rankings. Topics include value, momentum, quality, and volatility factors with exposure analysis.

Covers time-series and cross-sectional momentum strategies. Implement moving average crossovers, breakout systems, and CTA approaches with Python code.

Explains mean reversion through cointegration tests, pairs trading, factor-neutral portfolios, and regime risk management.

Covers quantitative trading fundamentals: alpha generation, strategy categories, backtesting workflows, and performance metrics for systematic investing.

Translate risk analytics into actionable controls through risk limits, hedging strategies, organizational governance, and regulatory frameworks.

Explains market depth, funding liquidity, operational risk, model validation, liquidity-adjusted VaR, and lessons from historical crises.

Explains Credit Valuation Adjustment for derivatives pricing, including exposure profiles, default probability modeling, and the broader XVA framework.

Covers credit risk modeling from Merton's structural framework to reduced-form hazard rates and Gaussian copula portfolio models with Python implementations.

Covers credit risk measurement through Probability of Default, Loss Given Default, and Exposure at Default. Topics include loan pricing and portfolio analysis.

Covers VaR calculation using parametric, historical, and Monte Carlo methods. Examines Expected Shortfall and stress testing for market risk management.

Covers market, credit, liquidity, operational, and model risk. Topics include Basel III capital requirements and risk management governance structures.

Covers Black-Litterman models, robust optimization, practical constraints, and risk parity for institutional portfolio management.

Covers Brinson attribution for sector allocation and selection effects, plus factor-based methods to separate investment alpha from systematic beta exposures.

Covers Sharpe ratio, Sortino ratio, information ratio, and maximum drawdown metrics. Evaluate portfolios with Python implementations.

Covers Arbitrage Pricing Theory and multi-factor models. Topics include Fama-French factors, estimate factor loadings via regression.

Covers Capital Asset Pricing Model: systematic risk, beta estimation, Security Market Line, and alpha. Essential foundations for asset pricing.

Covers model calibration techniques for quantitative finance. Topics include SABR, Heston, GARCH.

Covers Modern Portfolio Theory and mean-variance optimization. Topics include efficient frontier, diversification mathematics.

Covers PCA for extracting factors from yield curves and equity returns. Topics include dimension reduction, eigendecomposition.

Covers regression analysis for finance: estimate market beta, test alpha significance, diagnose heteroskedasticity.

Covers GARCH and ARCH models for time-varying volatility forecasting. Topics include estimation, persistence analysis, and dynamic VaR with Python examples.

Covers autoregressive and moving average models for financial time-series. Topics include stationarity, ACF/PACF diagnostics, ARIMA estimation, and forecasting.

Covers Black's model for pricing interest rate options. Value caps, floors, and swaptions with Python implementations and risk measures.

Covers Heath-Jarrow-Morton framework and LIBOR Market Model for pricing caps, floors, and swaptions. Implement forward rate dynamics in Python.

Covers Vasicek and CIR short-rate models for interest rate dynamics. Topics include mean reversion, bond pricing formulas, and derivative valuation techniques.

Covers exotic options pricing including Asian, barrier, lookback, and digital options. Topics include closed-form solutions and Monte Carlo simulation methods.

Covers finite difference methods for option pricing. Topics include explicit, implicit, and Crank-Nicolson schemes to solve the Black-Scholes PDE numerically.

Covers antithetic variates, control variates, and stratified sampling to reduce Monte Carlo simulation variance by 10x or more for derivatives pricing.

Covers Monte Carlo simulation for derivative pricing. Topics include risk-neutral valuation, path-dependent options like Asian and barrier options.

Covers binomial tree option pricing with the Cox-Ross-Rubinstein model. Price American and European options using backward induction and risk-neutral valuation.

Compute implied volatility using Newton-Raphson and bisection methods. Examines volatility smile, skew patterns, and the VIX index with Python code.

Covers option Greeks: delta, gamma, theta, vega, and rho. Topics include sensitivity analysis, delta hedging, and portfolio risk management techniques.

Covers the Black-Scholes formula for European options with Python implementation. Topics include derivation, the Greeks, put-call parity.

Derive the Black-Scholes-Merton PDE with Itô's lemma, delta hedging, and no-arbitrage assumptions, then connect the equation to option pricing.

Covers the no-arbitrage principle, replicating portfolios, and risk-neutral probabilities.

Covers Itô's Lemma with complete derivations and Python simulations. Topics include stochastic calculus, geometric Brownian motion.

Build mathematical models for random price movements. Topics include simple random walks, Brownian motion properties.

Examines heavy tails, volatility clustering, and the leverage effect in financial returns, with their implications for risk modeling.

Covers convertible bond valuation and analysis. Topics include conversion ratios, pricing models, warrants, preferred stock, and hybrid security structures.

Covers CDO mechanics, cash flow waterfalls, and correlation risk. Topics include tranche valuation, the Gaussian copula model, and lessons from the 2008 crisis.

Covers CDS pricing using hazard rates and survival probabilities. Topics include credit risk valuation, implied default probabilities, and spread calculations.

Covers interest rate swap fundamentals: cash flow mechanics, day count conventions, LIBOR to SOFR transition, hedging strategies, and market structure.

Covers option fundamentals including calls, puts, intrinsic value, time value, and put-call parity. Topics include payoff diagrams and basic trading strategies.

Covers forward and futures pricing with cost-of-carry models. Topics include no-arbitrage strategies, basis risk, minimum variance hedge ratios.

Covers FX market structure, currency forward pricing via covered interest rate parity, and hedging strategies. Topics include cross rates and forward valuation.

Covers option strategies by combining basic building blocks. Construct spreads, straddles, and iron condors to visualize payoffs and manage risk.

Covers commodity futures pricing with cost of carry models, convenience yield, contango and backwardation analysis, and optimal hedging strategies.

Covers forward and futures contracts: payoff structures, margin requirements, daily settlement, and hedging strategies for effective risk management.

Measure and manage bond interest rate risk using duration, convexity, and immunization. Topics include portfolio hedging and liability-driven investing.

Covers yield curve construction through zero rates, forward rates, and bootstrapping. Interpret curve shapes and build production-quality curves.

Covers financial data handling with pandas, NumPy, and Numba. Topics include time series operations, return calculations, and visualization for quant finance.

Covers bond pricing through present value calculations, yield to maturity analysis, and price-yield relationships. Topics include fixed income fundamentals.

Covers equity market fundamentals including stock ownership, order book mechanics, trading execution, and key valuation metrics for quantitative finance.

Covers root-finding, interpolation, and numerical integration for finance. Compute implied volatility, build yield curves, and price derivatives.

Covers continuous compounding, present value calculations, and differential equations. Essential tools for derivative pricing and financial modeling.

Covers derivatives, gradients, and optimization techniques essential for quantitative finance. Topics include Greeks, portfolio optimization.

Covers vectors, matrices, and decompositions for portfolio optimization, risk analysis, and factor models. Essential math foundations for quant finance.

Covers moments of returns, hypothesis testing, and confidence intervals. Essential statistical techniques for analyzing financial data and quantifying risk.

Covers probability distributions essential for quantitative finance: normal, lognormal, binomial, Poisson, and fat-tailed distributions with Python examples.

Covers probability distributions, expected values, Bayes' theorem, and risk measures. Essential foundations for portfolio theory and derivatives pricing.

Covers time value of money concepts: compounding, discounting, present value, annuities, and interest rate conventions essential for quantitative finance.

Compare TWAP, VWAP, and Almgren-Chriss execution algorithms. Covers the tradeoff between market impact and timing risk, implementation, and evaluation.

Covers interest rate swap valuation through bond portfolio and FRA methods. Topics include curve bootstrapping, DV01 risk measures, and hedging applications.