jeffheaton/app_deep_learning: the T81-558 PyTorch course notebooks from Washington University in St. Louis

A course repository, not a deep learning library

The problem this solves is not model serving or training infrastructure. It is the gap between reading about convolutional networks and writing one. Jeff Heaton teaches T81-558 at Washington University in St. Louis, and this repository holds the lecture notebooks that the course is built from. The README states the course covers classic neural network structures, CNNs, LSTMs, GRUs, generative adversarial networks and reinforcement learning, applied to computer vision, time series, security, natural language processing and data generation, with Python and PyTorch as the implementation tools.

The audience is narrow and specific. The README says no prior Python knowledge is required, but familiarity with at least one programming language is assumed. That is a real constraint on who gets value here. If you have never written a loop in any language, the first module will not hold your hand through syntax. If you have written Java, R or C and want to move into PyTorch, the notebooks are sequenced for exactly that reader.

The repository is not archived, and the last push to main was on 2026-09-01. The most recent tagged release is pre_summer_2026, dated 2026-04-20. Treat the release tag as the stable snapshot and main as the live teaching copy that changes as the semester runs.

How the notebooks are sequenced, and where the data comes from

The mechanism is a numbered notebook per lecture, named t81_558_class_NN_M_topic.ipynb, where NN is the module and M is the lecture within it. That naming is the whole architecture. There is no package to import, no entry point, no service. You open a notebook and run cells.

The modules build in a deliberate order. Module 1 introduces neural networks and closes with a lecture on acceptable AI use in the course. Module 2 covers numeric processing with PyTorch, deep learning with PyTorch, feature vector encoding, sequences versus classes, and a lecture titled Beyond the CPU. Module 3 is pandas work for tabular data: categorical and continuous values, grouping and sorting, apply and map, feature engineering. Module 4 handles training mechanics: persistence, early stopping, K-fold cross-validation, training schedules, regularization and dropout.

From there the sequence widens. Module 5 is computer vision, from image processing through CNNs, augmentation, transfer learning and a YOLO lecture. Module 6 is time series with LSTMs, transformers and Meta Prophet. Module 7 covers model structure, learnable layers, activations, normalization and tensor shapes. Module 8 turns to Kaggle, ensembles, hyperparameter search and Bayesian optimization. Module 9 reaches transformers, Hugging Face, embeddings, Stable Diffusion and ChatGPT, and Module 10 opens with a faces notebook.

Data flow is local. A few data artifacts sit at the repository root: mpg.pkl and person.json, plus jeffs_helpful.ipynb, which is not part of the numbered sequence. The README does not describe a download step for the main datasets, so expect the notebooks to pull what they need when a cell runs.

Installing the T81-558 environment and running a first notebook

The repository ships an install/ directory at the top level. That is where the setup instructions live, and it is the first thing to open after cloning, because the README itself does not spell out the environment. The repository layout points you at two steps: get the code, then read the install directory before running anything.

git clone https://github.com/jeffheaton/app_deep_learning.git
cd app_deep_learning
ls install/

The listing is the point. The install directory holds the environment definition, and what it targets determines whether you need a GPU, a specific Python version, or a conda environment. Read those files rather than guessing.

Once the environment is up, open a notebook from the repository root so the paths resolve against the files sitting next to it. Lecture 2.1, t81_558_class_02_1_pytorch_numerical.ipynb, is a reasonable first stop because it exercises tensors without requiring a dataset. You should see the notebook open with its cells unexecuted. Run them top to bottom. If the first cell fails on an import, the environment is wrong, not the notebook.

For a first real use with actual training, lecture 3.1, Should Neural Networks be Used for Tabular Data, and 4.1, PyTorch Persistence, are the pair that shows the full loop: load and shape a table, train, then save and reload the model. The mpg.pkl file at the root is the kind of small artifact those exercises work against.

Where this repository fails you

The biggest limitation is that it is courseware tied to a live semester. The README lists dated meetings, assignment due dates and a syllabus PDF hosted on S3. If you are not enrolled, you get the notebooks without the grading, the Kaggle competition or the instructor feedback that the objectives assume. The README states that understanding is demonstrated through applied programming assignments and a Kaggle competition, so the repository alone is a partial version of the course.

There is no test suite and no versioned API. The top level is notebooks, an assignments/ directory, prompts/, citations.bib and a licence file. Nothing here promises backwards compatibility between semesters, and the release tag pre_summer_2026 signals that snapshots are cut per class cohort rather than per semantic version.

Hardware is the second failure mode. Module 2 includes a lecture called Beyond the CPU, and later modules cover transfer learning, Stable Diffusion and transformers. Those are not CPU-friendly workloads in any practical sense. If you are on a laptop without a GPU, the early modules will run and the later ones will test your patience.

The third case where this is the wrong tool: if you need to ship a model. Nothing in the repository is structured as a deployable artifact. For production PyTorch work you want a library with pinned dependencies and tests, and this is a teaching sequence.

How it compares to a structured video course

The obvious alternative for a self-directed learner is a video-based deep learning specialization, such as the DeepLearning.AI courses. The difference in approach is not quality, it is medium and feedback loop.

A video course gives you a lecturer explaining a concept, then a graded programming assignment in a sandboxed environment where the tests run for you. You get immediate pass or fail. The trade-off is that the environment is abstracted away: you rarely debug a CUDA mismatch because the platform handles it.

This repository inverts that. You get raw notebooks that you run on your own machine, against your own Python and your own GPU. When something breaks, you fix it. The install/ directory exists precisely because that burden is on you. The upside is that the friction is the lesson: configuring PyTorch, managing environments and debugging tensor shape errors are the skills that transfer to real work. The downside is that a beginner can stall for a day on an environment problem that a hosted platform would have hidden.

A second alternative is the official PyTorch tutorials. Those are narrower and task-focused, and they are better when you already know what you want to build. This repository is better when you want the sequence decided for you.

Licence, maintenance and what an upgrade costs

The repository is licensed Apache-2.0, with a LICENSE file at the top level and a separate copyright.md. Apache-2.0 permits commercial and academic use, modification and redistribution, and it includes an explicit patent grant. It also requires that you preserve the licence and notice files and state significant changes. None of that is legal advice; read the LICENSE and copyright.md yourself before reusing the notebooks in your own material.

Maintenance is real but tied to the academic calendar. The last push to main was on 2026-09-01, and the releases are named for cohorts, with pre_summer_2026 dated 2026-04-20. That pattern tells you what to expect: the repository moves when a class is being taught, and the notebooks are revised for the current term. It is not a project with a public issue backlog driving a roadmap.

Upgrade cost is therefore low in the sense that there is nothing to upgrade. You do not pin a version and migrate. You re-clone, or you pull, and you accept that a notebook may have changed between terms. The one thing worth checking on each pull is install/, because a changed environment definition is the change most likely to break a working setup. If you forked the notebooks for your own teaching, diff the numbered files against upstream rather than assuming they are stable.

Editorial conclusion

Adopt this repository if you want a structured, semester-length path through PyTorch that moves from tensors to CNNs, LSTMs, transformers, GANs and reinforcement learning, and you are willing to read the install directory instead of expecting a package. Skip it if you need a versioned library with a published API and a test suite, because the top level is notebooks, assignments and a syllabus. Before cloning, open install/ and confirm the environment it targets matches your Python and CUDA setup, then check the current syllabus PDF for the schedule the repository follows. The last push to main was on 2026-09-01, and the most recent release is tagged pre_summer_2026 from 2026-04-20.

Frequently asked questions

Official sources

1. jeffheaton/app_deep_learning on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases