Issue #00: First Principles: Why Monthly Epoch?

The Monthly Epoch

Why I'm Writing This

Every morning, my feed is the same.

Thirty-second breakdowns of papers I've already read. Tutorials that rename variables from the official docs and call it a guide. LinkedIn posts about "the future of AI" written by people who've never debugged a gradient tape.

I'm not complaining about the internet. I'm just saying — if you're trying to understand why a model stops converging, or how attention actually computes similarity, or what happens inside a quantized model on a microcontroller with 520KB of RAM — that content doesn't exist in the scroll.

So I'm building it.

What Epoch Actually Means

In training, an epoch is one full pass of your dataset through the network. It's slow. It's expensive. And nothing meaningful happens after just one.

That's exactly the cadence this blog runs on.

Once a month — first Tuesday — one deep-dive issue. Thirty days of reading, building, breaking things, and writing it up. No filler, no "Top 5 AI tools" listicles. Just one hard concept, taken seriously.

I'd rather publish twelve genuinely useful posts a year than three hundred that waste your time.

What We're Actually Covering

I'm using Aurélien Géron's Hands-On Machine Learning with Scikit-Learn, Keras & TensorFlow as a baseline with other O Reilys' books as a baseline — not to recap it, but to use it as a launchpad into the parts textbooks gloss over.

Four main threads:

1.Deep Learning Under the Hood — custom TensorFlow layers, what's actually happening inside a CNN's spatial hierarchies, the raw mechanics of self-attention before the library abstracts it away.

2.Federated learning — the math of how networks actually learn. From vanilla gradient descent to adaptive momentum algorithms. Why Adam works. Why it sometimes doesn't. What FedAdam changes and why it matters for distributed training.

3.Reinforcement Learning — Markov Decision Processes without the hand-waving, building Deep Q-Networks, and the experience replay trick that makes them actually train.

4.Intelligence at the Edge — taking these ideas down to constrained hardware. Running optimized inference on an ESP32. What quantization costs you in accuracy. Where the bottleneck actually is when your hardware has 240MHz and no FPU.

Who This Is For

If model.fit() seems like a mysterious black box you're hesitant to explore — this is for you.

If you've ever wondered why your loss spiked at epoch 47, or what dying ReLUs actually look like in practice, or why your model performs great on val but collapses on device — you're exactly who I'm writing for.

This isn't a course. It's a record of someone going deep on one thing at a time and writing it up honestly — including the parts that didn't work.

A Bit About Me

I'm an undergrad CS student currently deep in machine learning and embedded systems. I'm not writing from a position of having figured everything out. I'm writing because documenting the process is how I actually learn, and I suspect some of you learn the same way.

If you've been looking for a place that treats you like an engineer and not a consumer, stick around.

Issue #02 — Coming First Tuesday of Next Month

The Vanishing Gradient & The Evolution of Optimizers

We're starting at the wound. Deep networks used to just... stop learning. Gradients would shrink to nothing ten layers back, and the whole thing would stall. Understanding why that happens — mathematically, not metaphorically — is what unlocks everything that came after: batch norm, residual connections, adaptive learning rates.

That's where we begin.