Start here
A few hand-picked reading paths grouped by what you might want to learn. Pick the one closest to your goal and follow the sequence — each step links to a chapter, and each path also points to its full category if you want to dig further.
How a network is put together and how it learns: the architectures and the PyTorch that runs them, then backpropagation and everything that decides whether the learning signal survives the trip — initialization, normalization, the learning rate, the loss, regularization — then what the trained network turns out to contain, and one network trained end to end to play Go.
What actually happens inside a transformer when you send a prompt, and why the hard parts — hallucination, prompt fragility, and the rest — keep turning out to be architectural rather than bugs.
From calling the LLM to running it as part of a long-running system — how generation works, how to prompt it, where it silently fails, how to compose it into an agent, what the runtime around it needs to provide, and the rest of what production keeps demanding.
Start with the transformer/logit machinery, then follow the post-training path: when a weight delta is worth writing, which objective should create it, and which modern fine-tuning knobs matter once the stage is chosen.
Where a model's dispositions actually come from. Start from how generation works and what fine-tuning changes, then follow preference learning — the stage that bends a likelihood machine toward what people prefer — into the personality, sycophancy, and emotional surface that fall out of it.
What happens under a single call to a model: why a GPU is fast at some operations and not others, where the time actually goes — computing or moving bytes — and why the same matrix multiplication can run fifty times faster when only the arrangement of the numbers changes. Then the generation and attention notes, where the same limits explain batching and the KV cache.
The unsupervised side of ML in three passes: the geometry each algorithm quietly assumes a cluster has, why on real text the representation you choose usually matters more than the algorithm, and everything after the fit — labelling clusters, validating them, and choosing K when nobody hands it to you.
From the file format the data lives in through ARIMA, SARIMA, and the rest of the classical-statistics toolkit — the no-neural-networks route to time-series forecasting.
The deep-learning route to a time-series forecaster — from how the data is stored and shaped through the neural architectures (recurrent, convolutional, hybrid, and what comes next), the training recipes that make them converge, and the post-training lifecycle that keeps them useful in production.
Spotting outliers and shifts in time-series data — from the file formats and the data shapes through preprocessing to the statistical baselines that flag what doesn't belong, and the deeper detection methods that build on them.
How data actually moves and lives in production: file formats, streaming queues, object stores, relational databases, and the other layers of the storage stack — what each is for and where they overlap.
How time keeps breaking LLMs — a training corpus that quietly knows the future of its own past, a runtime that can't tell five minutes from five hours between user turns, and the failure modes that fall out wherever the two meet.
Why a plain regression of outcome on treatment usually returns the wrong number, and the toolkit for fixing it — instrumental variables, regression discontinuity, fixed effects, control functions, and causal ML — built up around pricing, the worked example where every method earns its place.