Recap and final exam

Ten modules to go from a lone tensor to a model served over HTTP. Here is the course condensed, then the threads running through it.

The course at a glance

Module	What to retain
1. Tensors and graphs	Immutable tensor, mutable variable; tf.function traces once then stops running the Python
2. Sequential API	The loss follows from the label format; predict returns probabilities, not classes
3. Functional API	Creating and applying a layer are two acts; loss_weights is mandatory with multiple outputs
4. Custom layers	Weights in build via add_weight; override train_step rather than the whole loop
5. tf.data pipelines	shuffle before batch, prefetch last; too small a buffer yields single-class batches
6. Callbacks	save_best_only=True and restore_best_weights=True, neither enabled by default
7. TensorBoard	One directory per run; histograms reveal the silent pathologies
8. Transfer learning	trainable=False does not freeze batch normalisation; pass training=False at the call
9. Distributed training	batch_size is global and the learning rate must follow
10. SavedModel and serving	Preprocessing must be a layer, or it disappears on export

The threads running through the course

Training and inference are two regimes, and TensorFlow will not warn you. Dropout activates in one, not the other. Batch normalisation uses batch statistics, then its running averages. That switch is automatic inside fit, but it becomes your responsibility as soon as you write a custom layer (module 4) or freeze a pretrained base (module 8). Neither of those two mistakes raises an exception: they silently degrade results. It is the most frequent bug in this course, and it goes by a different name depending on where it appears.

Whatever is not in the artifact does not exist. Preprocessing written in the training script, a tf.Variable created without add_weight, a custom layer without get_config: in all three cases something necessary lives outside the object that is supposed to contain everything. The symptom differs — degraded predictions, a weight that never learns, a model that will not reload — but the cause is identical. Before exporting, the question to ask is always: is this artifact enough for someone who does not have my script?

The bottleneck is almost never where you look for it. The instinctive response to slow training is to add hardware. Modules 5, 7 and 9 propose the reverse order: measure with the profiler, fix the data pipeline, enable mixed precision, and only then distribute. The first two steps cost nothing and often deliver more than the third, which multiplies the bill.

Keras offers intermediate entry points, and knowing them saves you from rewriting everything. Between fit and a fully manual loop sits train_step. Between a standard layer and a low-level operator sits the Layer subclass. Whenever you feel tempted to abandon the infrastructure, look for the extension point: that is what preserves callbacks, TensorBoard and distribution.

The final exam

The exam has 40 questions covering all ten modules: the distinction between tensor and variable, the exact behaviour of tf.function and the causes of retracing, choosing the loss from the label format, building architectures with multiple inputs and outputs, writing a layer with its three methods, composing and ordering a tf.data pipeline, configuring callbacks, reading histograms, the two-phase transfer procedure, scaling batch and rate in distributed training, and exporting for serving.

Several questions present situations to diagnose: a print that appears only once, predictions that change between calls, validation accuracy that regresses during fine-tuning, a served model that answers differently from the local one, training that slows down after moving to four accelerators. Judgement is what gets assessed, not memorised API signatures.

On success, your certificate of completion is issued immediately; its number can be verified by any third party on the platform.

Before you start

Go back over the table above and, for each row, ask yourself "what symptom would I see if I got this wrong?". If you can explain why a print inside a traced function shows only once, why freezing a base is not enough when it contains batch normalisation, and why a served model can answer differently from the local one, you are ready. Good luck!

Final exam

Ready to validate this course?

40 questions drawn at random from the course bank · passing score 70% · verifiable PDF certificate issued immediately on success.

Start the exam

You need to be signed in to your InSkillML account with an active subscription. You can also start the exam from My courses.