Topic
Neural Network
21 episodes
-
Overview: Decoding Strategy
We finally slow down on decoding strategy, the rule that turns a model's next-token odds into the actual words you see. We use one hallway-and-doors picture to make greedy decoding, sampling, top-k, top-p, beam search, and newer decoding work feel less like magic knobs.
-
Overview: Sequence Modeling
We slow down and finally define sequence modeling, the idea underneath next-token prediction, language models, and a surprising amount of modern AI. We keep it grounded in one picture: covering the next word and training a model to guess what belongs there.
-
Overview: Model Generalization
We finally slow down and make model generalization click from the ground up: what it means, how you measure it, and why memorizing the training set is a dead end. We keep coming back to the same simple idea, because that’s the whole game.
-
Overview: Supervised Fine Tuning
We finally slow down and make supervised fine-tuning click, because we keep leaning on S F T like everyone already has the whole shape of it. We build it from the apprentice-and-worked-examples picture into the actual training loop, the examples, and the trade-offs.
-
Overview: Model Routing
We finally pin down model routing, because we throw the term around all the time and somehow never actually define it. We walk through how a router sends each request to the model most likely to handle it well, and why that can save cost, latency, and a lot of dumb overgeneralization.
-
Overview: Router
We slow down on Router, the little decision-maker inside many AI systems that sends each input to the right expert, model, or retrieval path. We use the triage-desk mental model and build from intuition to mechanism, trade-offs, and where routers still matter now.
-
Overview: Fine Tuning
We finally do the fine-tuning episode we kept circling, and we make the core idea click: you start with a pretrained model, then adjust its weights on your own examples so it behaves the way your task actually needs. We also dig into when that helps, when it doesn’t, and why the quality of the data is the whole game.
-
Overview: Embeddings
We’re finally doing a full pass on embeddings, because they keep showing up under half the things we talk about. We get into what an embedding actually is, why it turns meaning into usable coordinates, and why that little geometric trick sits under so much of modern AI.
-
Overview: Neural Network Parameters
We finally slow down and make neural network parameters click from the ground up: what they are, how training changes them, and why the final frozen numbers matter so much. We keep coming back to the same mental picture so it actually sticks, instead of just sounding like another ML buzzword.
-
Overview: Deep Learning
We finally slow down and make deep learning click: what the deep part means, how layers learn features, and why training needs data, compute, loss, backpropagation, and gradient descent all working together.
-
Overview: Classifier
We finally slow down and make classifier click from the ground up: what it is, how it learns, and why the boring details like labels, loss, and held-out tests matter. We keep it in first-person and keep it practical, because that’s the whole point of calling this a Classifier episode.
-
Overview: Loss Function
We’re finally slowing down and making loss function click: the scoreboard that tells a model how wrong it was, and the signal that lets training move in a useful direction. We also keep the usual Justy-Cody back-and-forth, because apparently even a loss function needs two friends arguing about it for forty minutes.
-
Overview: Sparse Activation
We finally sit down with sparse activation and make the idea click from the ground up: why only part of a model wakes up on each input, how routing makes that happen, and where the real trade-offs show up. We keep it concrete, because this one has been lurking under a lot of the stuff we keep talking about.
-
Overview: Natural Language Processing
We keep running into natural language processing everywhere, so we finally sat down and made it the whole point. We walk through what NLP is, why language is such a weird machine problem, and how the field moved from rules to learned representations.
-
Overview: Prompt Engineering
We’re finally doing the overdue deep dive on prompt engineering, the weirdly practical skill of getting language models to do the thing you actually meant. We keep coming back to it because the difference between a flimsy prompt and a good one is often the difference between nonsense and a usable product.
-
Overview: Transformer Architecture
We finally sit down and define transformer architecture from the ground up, because we keep throwing the term around like it’s obvious and it really isn’t. We use the attention-as-a-room-of-index-cards picture to make the mechanism click, then connect it to why Transformers became the backbone of modern language models.
-
Overview: Neural Network
We finally slow down on neural networks: what they are, how the little adjustable pieces learn from examples, and why this basic idea sits underneath so much of modern A I.
-
Overview: Autoregressive Generation
We finally slow down and make autoregressive generation click: the whole thing is just a model writing one token, then using what it wrote to choose the next one. We keep the focus on the loop, the trade-offs, and why that one-step-at-a-time setup is still the backbone of modern language models.
-
Overview: Agentic loops
We’re finally doing the overdue deep dive on agentic loops, the repeated observe-decide-act-observe cycle that makes AI systems feel like they’re actually working a problem instead of just answering once. We keep circling this idea, so we’re unpacking the mechanism, the trade-offs, and why it matters in practice.
-
Overview: Attention Mechanism
We finally slow down and explain the attention mechanism from the ground up: why models need selective focus, how query-key-value attention works, and why it became the engine under transformers, long context, and hybrid attention systems.
-
Overview: Tokenization
We slow down and explain tokenization from the ground up: how raw text becomes numbered pieces a model can process, why those pieces are usually subwords, and why the tokenizer quietly affects cost, context, language handling, and product behavior.