Neural Networks by Hand in TensorFlow and PyTorch: Deep Learning Frameworks in Practice
Signature Course No. 339 — A Signature AI Socratic Coaching Course.
No experience needed — your coach starts where you are.
A New Kind of Learning
Socratic coaching, delivered by an agentic AI coach.
Not a course you watch. An AI coach you work with.
The Lighthouse Coach begins by discovering how you think about the subject, teaches what is missing, and gives you realistic practice before asking you to prove that you can use it. You may test out of concepts you already understand, while capstones turn the learning into a practical plan, decision, conversation, or other real-world result.
The curriculum is deliberately authored; the AI delivers it through coaching. It is not an AI randomly generating lessons.
A coach that teaches by asking — not by lecturing
The Lighthouse Coach is an AI Socratic coach built on Cognosco Learning's Neural Networks by Hand in TensorFlow and PyTorch: Deep Learning Frameworks in Practice course, in the AI at Work category. It does not play videos at you. It holds a conversation: it asks you a question, listens to your answer, names the misconception it hears, affirms what you got right, and asks the next question — the way a great coach works in the room.
A framework will happily compute the wrong thing at great speed. The hand work is how you know. This course teaches the discipline that follows from that one fact: compute the neuron, the loss, and the gradient by hand first, on numbers small enough to hold in your head — then build in the framework, and check the framework against your arithmetic before you trust it on anything larger.
It starts by hand. One neuron — weighted sum, bias, activation — computed in a line, every product shown. Then layers and shapes, a loss computed by hand, gradients worked through a small network by the chain rule, and the single learning step that turns a gradient into a changed weight. If a number in this course cannot be recomputed with a pencil on a small example, the course does not ask you to trust it on a large one.
It works in two movements. First, Module 1 — By Hand, Then in Code — work through Concepts 1–9 (A Neuron by Hand; Layers and Shapes; The Running System; Loss by Hand; Gradients and Backpropagation by Hand; The Learning Step; The Same Network in TensorFlow; The Same Network in PyTorch; Checking the Framework Against Your Hand), finishing with The Dual-Framework Build Sheet; then, Module 2 — Learn, Hold Up, and Ship — work through Concepts 10–18 (Data Pipelines in Both Frameworks; The Learning Loop Made Explicit; Optimizers and Schedules; Regularization and Generalization; Debugging a Network That Will Not Learn; Convolutional and Sequence Shapes; Evaluation Beyond One Number; Saving, Loading, and Serving; The Framework Practitioner's Standard), finishing with The Production Readiness Pack.
Both capstones produce real artifacts — a dual-framework build sheet for the Halvern classifier: one network specified by hand, built in TensorFlow, built again in PyTorch, with a parity audit against hand arithmetic; and a production readiness pack for a Halvern model that is failing in instructive ways — its diagnosis worked in a fixed order, its honest evaluation in the quality owner's numbers, and its serving package, defended in writing.
The honesty standard is part of the course. TensorFlow and PyTorch are actively developed — import paths, function names, defaults, and saving formats change between versions — so the course teaches the durable architecture both frameworks share: tensors, layers, losses, automatic differentiation, optimizers, data pipelines, and the explicit learning loop. Where a specific name or default is version-sensitive, the course teaches the principle and marks the exact point to verify against the current documentation for the version you have installed.
The course is self-paced and always on — roughly 30 minutes per concept, about 9 hours in full, taken in as many sittings as you like. You can type your answers, or talk out loud: the Voice Coach speaks its questions and listens to your spoken replies. Learners who already know the material can test out concept by concept.
Neural Networks by Hand in TensorFlow and PyTorch: Deep Learning Frameworks in Practice is part of The Lighthouse Signature Series — the online counterpart to the one-day, in-person learning Cognosco Learning has delivered since 2002.
Course Facts
One full concept, coached end to end — free: verify your email and we’ll send you a link to start.
Already enrolled? Enter the course →
Diagnose → Learn & Practice → Prove → Capstone
Every learner moves through the same discipline a Cognosco instructor would insist on in the room.
Diagnose
The Coach starts where the course starts: with one neuron. Produce z from stated inputs, weights, and bias without reaching for a tool, and say which input is arguing against the output; rule on a reported sigmoid output of 1.4 before you see any code; find the bias-like standing adjustment in a spreadsheet model you know — the number that applied before any of the case's own numbers were considered. Every concept opens with three questions that locate where you actually stand, and your answers shape how deeply the Coach works the concept with you. Everyone begins with Module 1 — no skipping the foundations you only think you have.
Learn & Practice
Work each concept in conversation with the Coach — spoken or written — then practice it against realistic situations until it holds up.
Prove
Every concept ends in proof: answer the check cold and demonstrate the skill. Know it already? Test out and take credit immediately.
Capstone
Finish with two capstones — The Dual-Framework Build Sheet for Module 1 and The Production Readiness Pack for Module 2 — that pull the whole course together, and earn the certificate.
What You'll Learn
Hand first, framework second, parity always. Every automated move in this course is introduced as arithmetic you can do yourself, then shown in TensorFlow, then shown in PyTorch, then checked: the three answers — hand, TensorFlow, PyTorch — must agree within a stated tolerance, or the disagreement itself is the lesson.
Module 1 builds the network by hand, then in code. The neuron, layers and shapes, losses and gradients computed by hand; the running system — Halvern Textile Mills' defect classifier — stated once and held still; the same network declared in TensorFlow and written in PyTorch; and the parity discipline that proves the three forms are one network.
Module 2 makes the work production-shaped. Honest data pipelines in both frameworks, without leakage; the learning loop with its covers taken off; optimizers and schedules chosen on purpose; regularization matched to its cause; a debugging differential worked in a fixed order; evaluation beyond one number; and saving and serving so the evaluated model is the served model.
And it holds its boundary throughout. Neighboring courses in this library teach machine learning breadth and theory — what the families of models are, and when each family fits a problem. This course teaches framework fluency: build, debug, evaluate, and deploy the same networks in TensorFlow and in PyTorch, side by side, and move between the two without superstition.
What you will learn
- Compute a neuron, a forward pass, a loss, and a gradient by hand on small numbers, and state what each framework is doing when it automates them
- Design networks by shape — inputs, layers, outputs, batches — and count their parameters before building them
- Build the same network in TensorFlow and in PyTorch, load identical weights into both, and prove the outputs agree with each other and with your hand arithmetic
- Build honest data pipelines in both frameworks — splits, scaling fitted only where it should be, batches, and shuffling — without leakage
- Run and read the learning loop in both its covered and explicit forms, choose optimizers and schedules on purpose, and regularize a network that memorizes instead of learning
- Debug a network that will not learn, evaluate it beyond a single number, and save, load, and serve it so the model you evaluated is the model that runs
Everything in the course
- All 18 concepts of Neural Networks by Hand in TensorFlow and PyTorch: Deep Learning Frameworks in Practice, in 2 modules
- A starting-point check first — the Coach finds where you actually stand before teaching
- Learn, Practice, Prove for every concept — no passive video watching
- A test-out on every concept: prove you know it and move on
- The Voice Coach: talk with the Coach out loud — it speaks, listens, and replies
- A personal Learner Record of your work across the course
- Two capstone exercises: The Dual-Framework Build Sheet and The Production Readiness Pack
- A printable session summary whenever you pause
- The Lighthouse Coach completion certificate (Signature Series)
- Your progress is saved as you go — stop anytime, resume where you left off
Built for practitioners who build in both frameworks
Developers and analysts — who can write ordinary Python and now need to build neural networks in the two frameworks employers and teams actually use, rather than only read about them; and machine learning practitioners from the breadth courses who know the theory of models and now want the craft: shapes that line up, loops that run, gradients they can inspect.
Technical leads and reviewers — who are handed framework code to approve and need to tell a sound build from a plausible-looking one, in either framework.
Career changers with programming fluency — who want one honest route from a hand-computed neuron to a served model, with nothing important hidden. This course assumes you can read and write basic Python — functions, lists, classes at a reading level — and that you have met, at least in passing, the general idea of a model learning from examples.
Prefer to learn live and in person? The same material anchors Cognosco's one-day programs — browse the in-person catalog.
Start with A Neuron by Hand
$195 — introductory price. One payment. No subscription, no password to manage.
Here is exactly what happens when you enroll:
- Pay securely with Stripe — you are taken straight into the course
- Create your learner profile and begin the Module 1 starting-point check
- Save the access key you are given — it restores your enrollment on any device
- Learn at your pace; your progress is stored in your browser on your device
For the full voice experience, use Chrome and allow the microphone when asked. Typing your answers works everywhere, all the time. Questions before you enroll? Email hello@cognoscolearning.com.
Before you enroll
What is a Socratic coaching session?
A conversation, not a video. Your coach asks a question; you answer — out loud by voice, or by typing — and the coach responds to what you said: naming the misconception it hears, affirming what you got right, and asking the next question. You advance only when you have mastered each concept, so a finished course means the learning held.
How long does it take — and how long do I have?
About 30 minutes per concept. Learn in sittings of any length; your progress is saved as you go. You have a full year from purchase to finish, and you can revisit and retake within that year.
What does the certificate verify?
That you completed every concept and both capstones of this course. Anyone can confirm a Cognosco certificate online — enter its certificate ID on our verification page.
What if it isn't for me — what are the refunds?
If you have not started, cancel for a full refund within seven days of purchase. Once you have started, there is no cash refund — stop before finishing and we credit the full amount you paid toward any other course in the library (credit valid one year from your original purchase). Once you complete the course, no refund or credit applies.
More Signature Courses are coming
Neural Networks by Hand in TensorFlow and PyTorch: Deep Learning Frameworks in Practice is Signature Course No. 339. Leave your email and we'll send you news of future Signature Courses and Lighthouse updates as they are announced — nothing else.