Skip to content
All categories

ai

1239 posts

LLM Inference Is About Reading Weights and KV Cache Less Often | Stanford CS336 Lecture 10

Lecture 10 separates prefill from decode: prefill parallelizes and is often compute-bound, while decode is sequential and commonly bandwidth-bound. GQA/MLA, quantization, speculative decoding, continuous batching, and PagedAttention reshape that cost.

Benchmark and Profile Before Writing a Triton Kernel | Stanford CS336 Lecture 6

Lecture 6 turns GPU principles into kernels: benchmark scaling across shapes, profile actual calls and time, then implement GeLU, softmax, reductions, and tiled matrix multiplication in Triton. Speed begins with measuring correctly.

Multimodal Models Turn Images into Tokens, Then Reconcile Semantics with Detail | Stanford CS336 Lecture 17

Lecture 17 organizes CLIP/SigLIP, LLaVA, Qwen-VL, and Chameleon into three paths: contrastive encoders learn semantics, vision-encoder/projector/LM stacks provide understanding, and discrete image tokens enable generation. Resolution, token budgets, and modality balance constrain them all.

From Bytes to a Tokenizer—and What Deserves to Scale | Stanford CS336 Lecture 1

CS336's first lecture does not treat building a language model from scratch as reenacting every old technique. It separates mechanics, mindset, and intuitions, then uses BPE to show how raw bytes become trainable tokens.

Build Data, Tensor, and Pipeline Parallelism from Collectives | Stanford CS336 Lecture 7

Lecture 7 starts below FSDP APIs, building a communication language from broadcast, all-reduce, all-gather, reduce-scatter, and all-to-all before assembling data, tensor, and pipeline parallelism.

Align ZeRO, FSDP, and 3D Parallelism with Hardware Topology | Stanford CS336 Lecture 8

Lecture 8 moves from parallel primitives to system design: ZeRO progressively shards optimizer state, gradients, and parameters; TP, PP, SP, and EP split width, depth, sequence, and experts. Their composition must follow topology and dynamic activation memory.

Count FLOPs and Memory Before Asking Whether a Model Fits | Stanford CS336 Lecture 2

Lecture 2 reduces model training to tensors, FLOPs, bytes, and time: use einops to track dimensions, arithmetic intensity and roofline analysis to identify bottlenecks, then trade compute for memory with gradient accumulation and activation checkpointing.

RLVR Scales Reasoning with Verifiable Rewards, but GRPO Is Not Free PPO | Stanford CS336 Lecture 16

Lecture 16 moves from PPO to GRPO and RLVR. Math, code, and environment outcomes provide scalable rewards and avoid some preference-model overoptimization, but group-normalized advantages introduce difficulty and length bias while rollout infrastructure becomes the dominant cost.

Scaling Laws Are Extrapolation Tools, Not Crystal Balls | Stanford CS336 Lecture 9

Lecture 9 begins with log-log linear relationships between data and error, then uses scaling laws to compare architectures, optimizers, batches, and model-data allocations. The Chinchilla dispute shows how fitting methods, observed ranges, and deployment objectives change the answer.

Scaling Laws in Practice Must Scale Learning Rate and Batch Too | Stanford CS336 Lecture 11

Lecture 11 reads public recipes from MiniCPM, DeepSeek, Qwen, and Llama 3: hold most architectural ratios fixed, sweep learning rate and batch at small scale, then choose model/data allocation with IsoFLOPs. μP helps, but normalization, optimizers, and weight decay can break transfer.

SFT Teaches Imitation; RLHF Begins Direct Preference Optimization | Stanford CS336 Lecture 15

Lecture 15 divides post-training into imitation and optimization. SFT extracts pretrained capabilities from instruction-response data; RLHF uses pairwise feedback to bridge demonstrations and preferences. PPO and DPO both inherit data bias, reward overoptimization, and mode collapse.

aideep-dive

Daytona Agent Sandbox: A Forkable Computer for Every Agent

Daytona treats a sandbox as a long-lived computer that can start, pause, snapshot, and fork. It raised a $24 million Series A in 2026, while a Laude Institute case study reports 37,000 sandboxes in one week. It fits parallel evaluations and coding agents, but its core open-source repository is no longer maintained.

aideep-dive

Deepgram Voice Agent API: From Streaming STT and Turn Detection to TTS

Deepgram combines streaming STT, LLM orchestration, turn detection, barge-in, and streaming TTS over one WebSocket while preserving paths for standalone speech models and bring-your-own LLM or TTS.

aideep-dive

Dify as a Low-Code Agent Platform: From a Working Workflow to a Published AI App

Dify puts models, Knowledge, visual Workflows, Agents, Plugins, and application APIs in one workspace; this guide builds a minimal Workflow that can be tested, published, and called through the API, then explains when an Agent is actually warranted.

aideep-dive

DSPy: Compiling AI Programs with Signatures, Metrics, and Optimizers

DSPy replaces handwritten prompt strings with task Signatures, execution Modules, and Optimizers that compile better instructions and examples against a dataset and metric.

aideep-dive

E2B Agent Sandbox: Put Model-Generated Code in a Resumable microVM

E2B combines Templates, Firecracker microVMs, and process, file, and network APIs into an agent execution layer. Its real selection advantage is preserving memory and processes across pause and resume, not merely providing another code interpreter.

aideep-dive

ElevenLabs ElevenAgents: The Lifecycle from Realtime Speech to Phone Agents

ElevenLabs has expanded from a TTS vendor into the ElevenAgents platform: Scribe Realtime listens, Flash speaks, and the platform connects the LLM, turn-taking, tools, and telephony. The key choice is whether you need a voice model or the whole agent control plane.

aideep-dive

Fireworks AI: From Serverless APIs to Custom Model Deployments

Fireworks AI puts open-weight model evaluation, dedicated GPU deployments, and LoRA customization behind one API surface. Serverless fits low-volume starts, On-demand fits sustained traffic and custom models, while reserved capacity adds enterprise capacity guarantees.

aideep-dive

Flowise Deep Dive: From Assistant, Chatflow, and Agentflow to an EOL Migration Decision

Flowise uses Assistant, Chatflow, and Agentflow to cover simple assistants, single-agent systems, and multi-agent orchestration; however, its repository was archived in August 2026 and official EOL is scheduled for August 31, so new projects should not adopt it without a maintained fork and migration plan.

aideep-dive

Galileo Deep Dive: Experiments, Evaluators, and the Agent Observability Loop

Galileo connects dataset experiments, LLM/code/Luna evaluators, production traces, and runtime guardrails. It fits enterprises that need observability plus intervention, but the old Protect surface is deprecated and evaluator models do not replace human calibration or application security.