This is not a vibes-based AI course. You will derive gradient descent, implement backpropagation from scratch in NumPy before a framework ever does it for you, build CNNs that genuinely see and Transformers that genuinely attend. By the end, both the math and the code will make sense, not just one of them.
Most AI courses teach you to call .fit(). This one teaches you what happens after.
Calling a library function is not the same as understanding what it did. You can absolutely ship things that way, for a while, until the model misbehaves and you have no idea why, because you never actually understood gradients, loss surfaces, or what a neuron is doing with its weights.
So we go deeper than most courses dare to. You'll derive the math, then implement it, then, once you've earned it, hand the tedious parts to PyTorch. That order matters. Understanding first, convenience second.
Every hard idea gets a simulation you can poke: watch gradient descent actually descend, watch a decision tree actually split, watch attention actually attend.
Anyone ready to stop treating models like black boxes.
You should already be comfortable writing code, ideally in Python. Beyond that, the only real requirement is patience for the math, we promise it pays off. See which one you are, they're all welcome.
◯
Persona 01
The Tutorial Survivor
You've followed ten YouTube tutorials and copy-pasted a lot of working Keras code. You still couldn't explain what a gradient actually is if your life depended on it.
∑
Persona 02
The Math Major
You can derive almost anything on paper. You have never once opened PyTorch, trained a real model, or watched your beautiful equations actually converge, or fail to.
☉
Persona 03
The Kaggle Dabbler
You can call .fit() on a scikit-learn model and get a decent score. You have no real idea what's happening between those two lines of code.
◆
Persona 04
The Engineer Going Deep
You ship real software professionally. You're tired of AI being a black box you call through an API, and you'd like it to just be another system you understand.
Small classes • hybrid
Tiny classes. Fewer silent, wrong models.
Max 25 humans per class, so when your loss goes to NaN at a genuinely unreasonable hour, someone actually looks at your code instead of your Stack Overflow post from three years ago. Learn onsite in Bangalore or online from anywhere with a GPU or the patience to wait for one.
25
Small class size
Max 25 per class
Small enough that when your gradients explode, or worse, quietly vanish, someone actually derives the fix with you on a whiteboard.
●
Onsite
Learn in the room
In Bangalore? Join us at Ace Hacker, J.P. Nagar 7th Phase, for fast internet, a great teacher, and other humans to argue about optimizers with.
◉
Online
Beam in from anywhere
Same live class, same real teacher, from wherever you are. All you need is a laptop, Python, and a healthy respect for the chain rule.
One continuous course
From "fit a line" to a Transformer you built and understand.
Eight weeks, eighteen chapters, one steadily deepening technical foundation, taught as a single continuous course, not separate levels. Classical ML, neural networks from scratch, and the full Transformer era, back to back, each chapter building cleanly, and rigorously, on the one before it.
Start to finish
Backprop
AI & ML Programming, in depth
Regression and classical ML, then neural networks from scratch, then the full Transformer era, all in one 8-week course.
Don't take our word for it. Watch the algorithms run.
Six real, correctly-computed simulations, not illustrations pretending to be math. Race three optimizers down an actual loss surface, watch a decision tree actually compute Gini impurity, watch real softmax attention weights form. This is how the whole course feels: fewer slides, more "wait, run that again."
Weeks 1 & 5 • optimization
Gradient Descent: Three Ways
Same elongated loss bowl, three optimizers racing to the bottom. Plain SGD zig-zags. Momentum smooths the ride. Adam adapts its step size per parameter. Same math, wildly different paths.
steps: 0loss: —
Week 3 • bias-variance
Overfitting & How to Tame It
Fit a polynomial to noisy data. Crank the degree up and it memorizes the noise. Crank regularization (λ) up and it calms back down. Watch train and test error tell two different stories.
train error: —test error: —
Week 2 • trees
A Decision Tree, Growing Live
Real Gini-impurity splits on real 2D data, computed on the fly, one level at a time. Watch the decision boundary carve itself out of straight lines, and see exactly why trees overfit if you let them.
depth: 0leaves: 1train accuracy: —
Week 3 • evaluation
The Confusion Matrix, Live
Same 40 predictions, one threshold slider. Move it and watch precision, recall, and F1 genuinely recompute, and watch the trade-off between "catch everything" and "don't cry wolf" play out in real numbers.
precision: —recall: —F1: —
Week 7 • transformers
Attention: Which Words Matter
Click a word to make it the query. Real dot products against every other word's key, run through a real softmax, decide how much attention it pays to each. The weights genuinely sum to one.
click a word above to see what it attends to
Week 3 • unsupervised
K-Means: Watch Clusters Form
No labels, just points and three centroids. Each step: assign every point to its nearest centroid, then move each centroid to the mean of its points. Repeat until nothing moves.
iteration: 0centroids placed randomly
Six simulations here. The course is packed with them, one for nearly every algorithm, live in class too.
The chapters
Eighteen chapters. No hand-waving, anywhere.
The full journey, from your first least-squares fit to a Transformer you understand from the attention weights up. It's genuinely deep, real derivations, real implementations, real training runs, just told by people who enjoy explaining why your gradients vanished. Every chapter comes with visuals, a simulation you can poke, and real code you write yourself.
Week 1 • 2 chapters. Linear regression from first principles, then the mechanics of gradient descent, your first trained model and the algorithm that got it there.
Chapter 1
Fitting a Line Through Chaos
Linear regression from first principles: the cost function, the normal equation, and your first genuinely trained model, derived by hand before it's ever called from a library.
You'll learn: linear regression, cost functions, the normal equation, and your first trained model.
Chapter 2
Descending, Responsibly
Gradient descent mechanics: learning rate, convergence, and exactly why a step that's too big sends your loss straight to infinity.
You'll learn: gradient descent, learning rate, convergence, and why step size matters so much.
Week 2 • 2 chapters. Logistic regression and decision boundaries, then decision trees, Gini impurity, and random forests.
Chapter 3
Drawing the Line: Classification
Logistic regression, the sigmoid function, and decision boundaries, turning a regression model into something that can actually say yes or no.
You'll learn: logistic regression, the sigmoid function, and decision boundaries.
Chapter 4
Trees, Forests, and Why They Vote
Decision trees split on Gini impurity, and random forests that outvote any single tree's bad day.
You'll learn: decision trees, Gini impurity and information gain, random forests, and ensembles.
Week 3 • 2 chapters. Honest evaluation, train/test splits, cross-validation, and the metrics that matter, then unsupervised learning with k-means and a first look at PCA.
Chapter 5
Grading Your Own Homework Honestly
Train/test splits, cross-validation, and the metrics, precision, recall, F1, ROC, that actually tell you whether your model works.
You'll learn: train/test splits, cross-validation, overfitting, and evaluation metrics that matter.
Chapter 6
Finding Structure Nobody Labeled
Unsupervised learning: k-means clustering and a first proper look at dimensionality reduction with PCA.
You'll learn: k-means clustering, unsupervised learning, and an introduction to PCA.
Checkpoint • end of week 3
Checkpoint: you can build and evaluate real ML models
A hands-on project: a complete classical ML pipeline, from raw data to a properly evaluated model, built with scikit-learn and understood well enough to explain every line. Onward to the part where you build the models yourself.
Week 4 • 2 chapters. The perceptron and exactly why one neuron alone can’t do very much, then backpropagation derived properly as computational graphs and the chain rule.
Chapter 7
One Neuron, Doing Its Best
The perceptron: weights, biases, and activation functions, and a clear-eyed look at exactly why one neuron alone can't do very much.
You'll learn: the perceptron, weights and biases, activation functions, and their limits.
Chapter 8
The Chain Rule, Weaponized
Backpropagation derived properly, as computational graphs and the chain rule, not as a mysterious black box a framework runs for you.
You'll learn: backpropagation, computational graphs, and the chain rule that powers deep learning.
Week 5 • 2 chapters. A neural network built from nothing but NumPy, forward pass to weight updates, then the same thing in PyTorch with real autograd and a real training loop.
Chapter 9
Building a Neural Net With Nothing But NumPy
Forward pass, backward pass, weight updates, implemented by hand. No autograd, no shortcuts, just you and the math you just derived.
You'll learn: implementing a neural network from scratch, forward and backward passes, and weight updates.
Chapter 10
Now Let Someone Else Do the Calculus
PyTorch and autograd: the same math you just implemented by hand, now computed automatically, and a real training loop.
You'll learn: PyTorch, autograd, tensors, and writing a real training loop.
Week 6 • 2 chapters. Convolutional neural networks that genuinely see, then RNNs and LSTMs for sequence data and the vanishing gradient problem.
Chapter 11
Teaching a Network to See
Convolutional neural networks: filters, pooling, and building a genuine image classifier from the ground up.
You'll learn: CNNs, convolutions, pooling, and building an image classifier.
Chapter 12
Teaching a Network to Remember
RNNs and LSTMs for sequence data, and an honest look at the vanishing gradient problem that eventually led to something better.
You'll learn: RNNs, LSTMs, sequence modeling, and the vanishing gradient problem.
Checkpoint • end of week 6
Checkpoint: you can build a neural network from nothing
You'll implement a working neural network from scratch in NumPy, then rebuild it in PyTorch, then train a CNN and an RNN on real data. Then we go where the field actually is right now.
Week 7 • 3 chapters. Self-attention derived from scratch, the full Transformer architecture end to end, then transfer learning and fine-tuning a pretrained model.
Chapter 13
Attention Is, In Fact, All You Need
Self-attention derived from scratch: queries, keys, values, and the softmax that decides what a word should pay attention to.
You'll learn: self-attention, queries/keys/values, and multi-head attention.
Chapter 14
The Architecture That Ate NLP
The full Transformer: positional encoding, encoder-decoder structure, and how it all fits together into one architecture.
You'll learn: the Transformer architecture, positional encoding, and encoder-decoder structure.
Chapter 15
Borrowing a Model That Already Knows Things
Transfer learning and fine-tuning: standing on the shoulders of a model someone already spent a small fortune training.
You'll learn: transfer learning, fine-tuning, and using pretrained models effectively.
Week 8 • 3 chapters. Training at a scale that complains, experiment tracking and MLOps fundamentals, and shipping a real, deployed model as the course capstone.
Chapter 16
Training at a Scale That Complains
Batching strategies, mixed precision, and the basics of distributed training, for when your model stops fitting comfortably on one GPU.
You'll learn: batching, mixed precision, and the basics of training larger models efficiently.
Chapter 17
Keeping Score Like a Grown-Up
Experiment tracking, hyperparameter tuning, and the MLOps fundamentals that separate a real project from a folder of notebooks named final_v3.
You'll learn: experiment tracking, hyperparameter tuning, and basic MLOps practices.
Chapter 18
Ship a Model That Works in the Real World
The finale: deploying a trained model as a real, working application that serves real predictions to real requests.
You'll learn: model deployment, serving predictions, and shipping a complete ML-powered application.
The finale
Capstone: a real, trained, deployed model, understood end to end
You'll design, train, and ship a complete machine learning application, of your choosing, and be able to explain every layer of it, from the loss function up to the deployed API. Then you get to say, casually, "yeah, I derived the backprop for that myself."
Why sign up
What's in it for you.
Beyond the ability to say "well, technically that's a saddle point, not a local minimum" in a meeting and be correct, here's what you actually walk away with.
✓
Benefit 01
You'll actually understand the models
Not "called a library" understand. Real, load-bearing understanding of the math and the code, from gradient descent to attention.
▲
Benefit 02
Depth that actually shows in interviews
Anyone can say they know ML. Deriving backprop on a whiteboard, or explaining why your model overfit, is what separates you from the tutorial crowd.
⎈
Benefit 03
You'll ship a real, trained, deployed model
By the end you will have trained models across classical ML, deep learning, and Transformers, and deployed one as a real, working application.
★
Benefit 04
The scary math becomes intuitive
Gradients, the chain rule, softmax, we drill them with visuals and simulations until they stop feeling abstract and start feeling like tools you reach for.
Schedule & fees
Pick a pace that fits your reality.
Weekday and weekend batches for the same 8-week course. Timings are in India Standard Time. Pick whichever slot fits your life, from your first cost function to a shipped Transformer-based app.
Weekday batch
Weekdays, Mon to Thu
Ninety minutes a day, four time slots to choose from, morning through evening. Steady, digestible doses of math and code that won't wreck your week.
Weekend batch
Deep dives, Sat & Sun
Three hours each on Saturday and Sunday, for people who'd rather keep weekdays clear and get properly stuck into a derivation for a few hours at a stretch.
Paying from India? Use ₹ / UPI. Paying from outside India? Switch to $ / PayPal — each batch row below has its own switch, right next to its price.
Three hours each on Saturday and Sunday, for people who’d rather keep weekdays clear and get properly stuck into a derivation for a few hours at a stretch.
All six batches cover the same 8-week course. EMI available on select cards. Fees are indicative and may be revised.
Certification
Proof you understand it, not just call it.
Complete the course and earn a certificate, based on your work across simulations, projects, and the final model, you get one of two. Both look great on a wall and better on a resume.
Top tier
Certificate of Excellence
For standout work across the derivations, implementations, and the capstone. Translation: you didn't just train a model, you could explain, and defend, every choice in it.
On completion
Certificate of Completion
For finishing the course and genuinely getting the ideas. Suitable for framing, LinkedIn, and confidently correcting anyone who calls gradient descent "just trial and error."
Practice
Learn it by actually deriving it.
You don't learn machine learning by watching a diagram of a neural network. You learn it by implementing backprop yourself, watching it fail, and finding the exact line where your derivative is wrong.
Simulations
Poke till it clicks
Interactive labs for every hard idea, gradient descent, attention, decision trees, so the abstract math becomes something you've actually watched happen.
Real math, real code
Derive it, then implement it
Every major algorithm gets derived on a whiteboard, then implemented in NumPy or PyTorch, then trained on real data. Both halves, every time.
Projects
Ship a real, trained model
You’ll build and evaluate three real projects along the way: a classical ML pipeline, a neural net from scratch, and a full Transformer-based capstone, deployed live.
The themed hackathon
The Model Bake-Off
Every cohort ends in a live build sprint. Grab your crew, pick a real dataset or problem, and train, tune, and ship a working model before the clock runs out. No pre-trained shortcuts allowed for the core task.
Present your results live, defend your architecture and hyperparameter choices, and the best-performing, best-explained models walk away with prizes, glory, and the rare bragging right of having out-trained the room.
Live, interactive sessions with real teachers, real snacks, and a room, physical or virtual, built for genuinely deriving things on a whiteboard together.
BYOD
Bring your own device
Any laptop that can run Python works. We use free-tier cloud GPUs for the training-heavy sessions, no personal GPU required.
Your teacher
Has debugged a vanishing gradient or twelve
Your teachers have trained real models professionally, and get a little too excited explaining exactly why your loss went to NaN. The enthusiasm is contagious.
Be punctual
The door closes on time
Arrive early for snacks and chai if you're onsite. Class starts sharp, and since every chapter builds on the last, being on time is a gift to your future, less-confused self.
Looking for us?
Ace Hacker, Bengaluru
3rd Floor, No. 670, RBI Layout Main Road, J.P. Nagar 7th Phase, Bengaluru 560 078, Karnataka, India.
Taught by people who derive backprop for fun, apparently.
You will be taught by a small team of engineers who train real models professionally and can explain the chain rule without a single intimidating word.
They've spent years turning "I just call model.fit()" into "here's exactly what that function is doing, and why," and they still light up every time a student's from-scratch neural network trains correctly for the first time. It's a little much. It's also exactly what you want in a guide.
Initialize the weights
Somewhere out there, your loss is waiting to converge.
The math is learnable. The code is learnable. Most people never get taught both properly, in order, with time to actually derive things. Go on. Take the first gradient step.
Hybrid classroom • small classes • EMI & scholarships available
Questions
The things everyone asks.
Comfort with high-school algebra and a willingness to learn calculus and linear algebra as we go. We teach the specific math each chapter needs, from first principles, right when you need it, not as a scary prerequisite wall.
Yes, you should already be comfortable writing code, ideally Python. This isn't a "learn to code" course, it's a "learn how these algorithms actually work" course.
Both, deliberately. Every major idea gets derived on a whiteboard and implemented in code. We think the two halves of understanding reinforce each other, so we never teach just one.
Yes, around week 4, in plain NumPy, with no autograd doing the calculus for you. Only after that do we move to PyTorch, so the automation feels earned instead of magical.
No. We use free-tier cloud GPUs for the training-heavy sessions from week 4 onward. A normal laptop is enough for everything else.
Yes, in depth, in the final two weeks: self-attention, multi-head attention, positional encoding, and the full encoder-decoder architecture, derived and implemented, not just described.
A full classical ML pipeline in the first three weeks, a neural network built from scratch plus CNN and RNN projects by week 6, and a complete, deployed, Transformer-based capstone application by the end of week 8.
Fully live, with a real teacher and real classmates: ask questions, get answers, get a derivation re-explained in real time. If you have to miss one, we'll share a recording so you can catch up.
Yes, via EMI on select bank credit cards including SBI, ICICI, Axis, HDFC, Kotak, HSBC, and others. Tenures and interest are set by your bank, and the arrangement is strictly between you and them. Just choose the EMI option at payment with an eligible card.
We do, under the Ekalavya Scholarship program. If cost is the only thing between you and this course, reach out and tell us your story. We're listening.
Vivek Shangari, Chief Geek at Ace Hacker, with a small team of engineers who train real machine learning models for a living.
Still deciding?
Talk to a human, not a chatbot.
Questions about the syllabus, prerequisites, or whether "I once fit a trendline in Excel" counts as regression experience (it's a start)? We're happy to talk it through, zero pressure.
