405 items · Page 4 of 9
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.
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.
Transform raw text into structured data using named entity recognition, relation extraction, event extraction, and LLM-based JSON output generation.
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 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.
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.
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.
Walk through the complete lifecycle of a quantitative trading strategy. Build a pairs trading system from scratch with rigorous backtesting and risk management.
Explains how learning rate schedules improve neural network training. Topics include step decay, exponential decay, inverse square root with warmup.
Covers ethical quantitative trading by learning to detect spoofing, navigate Reg NMS and MiFID II, implement kill switches, and ensure data privacy compliance.
Explains how embedding models convert text to vectors for RAG. Topics include bi-encoder architecture, pooling strategies, dimensionality trade-offs.
Covers optimal position sizing using the Kelly Criterion, risk budgeting, and volatility targeting.
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.
Build a robust quantitative research pipeline. From hypothesis formulation and backtesting to paper trading and live production deployment strategies.
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.
Examines quantitative trading-system architecture, including data pipelines, strategy engines, risk controls, and execution infrastructure.
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.
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.
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.