Deep-Learning Vision to YOLO, From the Ground Up: Convolution, Receptive Field, Anchors, the Three-Part Loss, NMS, Data Handling, and a Troubleshooting Tree
From "why can't we feed images to an MLP" all the way down: convolution and receptive field, Backbone/Neck/Head and FPN, YOLO's grid bet, the anchor mechanism and anchor-free, the three-part loss and CIoU, NMS and NMS-free, the v1→v12 evolution logic, then data annotation/augmentation/class-imbalance and training tuning, closing with a troubleshooting tree. Every term unpacked to the bottom, examples grounded in the factory floor.
AI Agents from the Ground Up, Layer by Layer: From "Only Predicts the Next Token" to an Acting Closed Loop — Loop, ReAct, Tools, Memory, Planning, Reflection, and Design
A bare LLM is a stateless function that only predicts the next token and can't touch the world. An AI agent is the system that bolts capabilities onto it and wires them with a closed loop. This article stacks it up layer by layer with the mechanism of each: the agent's heart is a loop, not a single call; how CoT→ReAct grounds reasoning; the truth of function calling (the LLM only generates compliant JSON, the harness executes) including MCP; memory as short-term context vs long-term RAG (Generative Agents' recency+importance+relevance); ReWOO/ToT for planning; Self-Refine/Reflexion for reflection; and Anthropic's workflow-vs-agent for design, with a full architecture diagram and manufacturing grounding.
The Three Cores of VAEs, All the Way Down: Latent Space, the Reparameterization Trick, KL Divergence — and How the "KL as Anchor" Pattern Reappears in RLHF
Starting from the manifold hypothesis, this article defines latent space (and breaks the loose analogy: LLM hidden states ≠ VAE latents), uses the plain autoencoder as the control group to expose the defect — a latent space shattered into islands that compresses but cannot generate — then dissects the VAE's fix: the encoder outputs μ/σ distribution parameters, sampling noise extorts continuity, and the reparameterization trick (z = μ + σ⊙ε) rearranges the computation graph to restore gradient flow. It reads KL divergence term by term (definition, asymmetry: mode-seeking vs mass-covering, Gaussian closed form), shows how KL anchors the model against σ→0 degeneration and how the opposite imbalance causes posterior collapse, then abstracts "primary objective + β·KL anchor" into a design pattern that reappears verbatim in InstructGPT's KL penalty against reward hacking and DPO's β — closing with practical applications (Stable Diffusion's latent substrate, manufacturing anomaly detection) and a tuning memo.
LoRA Parameters from First Principles: the B·A Decomposition, Rank, α/r Scaling, and Gaussian Initialization
What do LoRA's A (r×k) and B (d×r) each actually adjust? Starting from the cost structure of full fine-tuning, this article dissects the low-rank data flow (A picks which r directions to read from the input, B picks which r directions to write to the output), r's dual role as capacity ceiling and forgetting brake, why α/r scaling acts as an effective learning rate and why high rank needs α/√r (rsLoRA) — then goes deep on Gaussian initialization: why zeroing B guarantees a zero start, why a random A breaks the symmetry, why zeroing both traps you on a saddle point forever, how the variance connects to Kaiming init, and why the mirror scheme trains worse — ending with a practical tuning table derived entirely from mechanism.
Attention's Q/K/V from the Ground Up: Why Dot Product Isn't Cosine, How Softmax Allocates Values, and How Soft Prompts Get Injected into Every Layer's KV
Q/K/V are the same hidden vector times three trained projection matrices — why three? Because matching in language is asymmetric. This article dissects the attention formula term by term: q·k uses the dot product, not cosine (vector length is the model's volume knob); dividing by √d_k prevents softmax saturation; "whose value to take" is no hard selection but a softmax-weighted blend of all values. It then opens the black box from the PEFT article — a soft prompt's trainable vectors are just a randomly initialized nn.Parameter block, carved by gradients and concatenated into every layer's K/V via past_key_values, seen but never asking — with mechanistic contrasts to Prompt Tuning and LoRA.
Multi-Agent Systems from the Ground Up: How One Agent Loop Becomes Many, How Memory Is Shared, and Which Designs Actually Work
Multi-agent is not mysterious new machinery — in the dominant implementations, spawning a subagent is just one more tool call. Starting from the bare agent loop, this article derives a single agent's three fundamental limits (context ceiling, sequential execution, role mixing) and shows how multi-agent structurally solves them by opening more context windows; it then dissects the four layers of memory sharing (message passing, blackboard, shared state, long-term memory), seven design patterns arranged by who holds control, and the boundary drawn jointly by Anthropic's measured 15x token cost and Cognition's counterargument: read-heavy breadth-first tasks win big, write-heavy coupled tasks should stay single-threaded.