TensorFlow-Examples: every network in section 3 classifies the same MNIST digits

The 05/16/2020 update moved every default example to TF2 and parked v1 in its own tree

The README opens with a dated change notice: `Update (05/16/2020): Moving all default examples to TF2.` Every link in the tutorial index resolves under `tensorflow_v2/notebooks/`, and the notice sends anyone who still needs the old session-graph style to a separate `tensorflow_v1` directory. So the root of the repository holds two version trees, `tensorflow_v1/` and `tensorflow_v2/`, and the index only ever points into one of them. Here is what that costs you. If your own code is on the v1 API and you follow the notice into the v1 directory, you get a folder and no matching table of contents: the numbered headings you already learned from the v2 side do not line up with files you now have to open one at a time to identify. The 2020 line is also the only statement in the repository about which examples are current, and it predates the last commit on the default branch, dated 2024-07-26, by four years.

Two notebook trees sit at the root, and only one of them is in the index

The top-level entries are `.gitignore`, `LICENSE`, `README.md`, `examples/`, `input_data.py`, `notebooks/`, `resources/`, `tensorflow_v1/`, and `tensorflow_v2/`. The index links point into `tensorflow_v2/notebooks/`, yet a separate `notebooks/` directory also exists at the root, and `examples/` carries its own numbered run, `1_Introduction/` through `6_MultiGPU/`, with its own `README.md`. Nothing states which notebook tree is the one to open, or what `input_data.py` and `resources/` are for. The practical consequence is that cloning and searching by filename can land you in a copy the index never references, and a stale notebook does not announce itself as stale: it is a valid file that runs or fails on its own terms. Read the path inside the link before you trust the file you just opened, and compare the two trees before assuming the one you found is the maintained copy.

Section 3 stays on MNIST from the first classifier to the last

Section 3 is the bulk of the index: a simple neural network, that same network written low level, a convolutional neural network, its low-level twin, an LSTM, a bi-directional LSTM, and a dynamic LSTM for variable-length sequences. All seven classify MNIST digits. Across the rest of the tutorial only three other datasets appear, Boston Housing for the gradient boosted decision tree, Wikipedia text for the Word2Vec embedding, and images for the auto-encoder and the DCGAN. The consequence for a reader is a narrow picture of what these architectures do on real data. Nothing in the index shows a target with class imbalance, a CSV with missing values, a multi-label problem, or a dataset that will not fit in memory, and no entry reports the accuracy or loss you should expect to reach, so you get a working cell and no reference point for judging it. A notebook that runs is not the same as a notebook whose output you can check.

Paired API and raw notebooks are the one idea the repository actually repeats

Several models ship twice. `neural_network.ipynb` builds the MNIST classifier with the `layers` and `model` API, and `neural_network_raw.ipynb` is the raw implementation of that same classifier. `convolutional_network.ipynb` and `convolutional_network_raw.ipynb` repeat the arrangement for the conv net. The pairing is the clearest thing on offer, because reading both versions of one model shows you precisely what the higher-level API hides. The cost is that the index describes the two with nearly the same sentence, so nothing warns you that the low-level files hand-build the pieces the API version receives for free. The two files are also free to drift apart, since they are separate documents with separate histories, and a change to one is not obliged to reach the other. Treat the pair as two views of an idea, not as a tested equivalence between them.

No install line, no requirements file, and no release to pin against

The README gives no pip command, no environment file, and no version requirement, and the root listing contains no `requirements.txt` and no `pyproject.toml`. The repository has no GitHub releases, so there is no tag to check out and no changelog to read. The only version anchor anywhere is the 05/16/2020 line, which names `layers`, `estimator`, and `dataset` as the current API practices, and those names date from that notice. The last commit to the default branch `master` is 2024-07-26. That leaves you choosing the TensorFlow version yourself, and if the release you install has moved on from the API names in the cells, the failure arrives as an error on a notebook cell rather than as an install step telling you which release was meant. Check the imports in the first cells of a notebook against the version you installed before you plan anything around it.

Utilities and data management are separate notebooks you must wire together

Section 4 covers saving and restoring a model, building custom layers and modules, and tracking the computation graph, metrics, and weights with tensorboard. Section 5 covers building a data pipeline from Numpy arrays, images, CSV files, and custom data, converting data into the TFRecords format and loading it back, and applying image augmentation to generate distorted images for training. Each is its own notebook, and no index entry combines them. So a reader who wants a realistic training loop has to join checkpointing, a TFRecords input, augmentation, and tensorboard logging by hand, and the repository does not state what a restored checkpoint expects to find or what schema the TFRecord writer emits. The gain is isolation and readability, one mechanism per file. The cost is that the loop you end up running is yours, assembled from four notebooks that never ran next to each other.

The index stops at multi-GPU training, with nothing about serving or deployment

The tutorial index is numbered 0 through 6 and ends at Hardware, where the listed item is a multi-GPU training notebook. Past that point there is no entry for exporting a model, serving it, running it on a phone or in a browser, or watching it in production, and the hardware the multi-GPU notebook expects is not spelled out, so you get no count of devices and no named distribution strategy to check your machine against. For a reader whose goal is a live service, this repository walks the training half and stops. The maintenance picture is the same shape. The repository is not archived, and it carries a LICENSE file, but its license field carries no assertion and the last commit to the default branch is 2024-07-26, so the notebooks are a learning surface with a date on it, not a template with a version you can rely on.

Editorial conclusion

Use it when you want short, paired notebooks for one model at a time and you already know which TensorFlow version you are targeting. Skip it if you need a deployment path, a pinned environment, or examples on anything other than MNIST. Before you rely on a notebook, check its imports against the TensorFlow version you installed, and read the LICENSE file at the root, because the license field carries no assertion.

Frequently asked questions

Official sources

1. Official README
2. Project repository