712 items · Page 4 of 15
Create a free account to keep your reading organized, join thoughtful discussions, and get more from every chapter.
Free to join · Takes less than a minute
Why
I created this space so readers can learn together, ask questions, and make sense of difficult ideas.
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 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.
Create a free account to keep your reading organized, join thoughtful discussions, and get more from every chapter.
Free to join · Takes less than a minute
Why
I created this space so readers can learn together, ask questions, and make sense of difficult ideas.