Recap and final exam

Ten modules to go from "order matters, and a table hides that" to a calibrated 24-hour forecast of a building's electricity consumption. Here is the course condensed, then the ideas that thread through it, then the exam.

The course at a glance

Module	What to retain
1. Sequence vs table	A dense network ignores order; sliding windows create examples; shuffled splits leak the future
2. Recurrent neuron	Shared weights across time, (batch, time, features), return_sequences decides what flows to the next layer
3. BPTT	Memory scales linearly with sequence length; truncated BPTT and stateful RNNs are the two escape valves
4. Vanishing gradients	The BPTT product $\sigma_{\max}^{\,k}$ dies or explodes; clip the norm, initialise orthogonally
5. LSTM	Cell state and hidden state; three gates; the additive cell path saves the gradient over hundreds of steps
6. GRU	Two gates, 75 % of the LSTM parameters; often the pragmatic default on short-to-medium sequences
7. Bidirectional and stacked	Bidirectional only when the whole sequence is available; stack two to three layers, no more
8. Encoder-decoder	Context vector, teacher forcing, <sos> / <eos>, greedy decoding; the bottleneck that motivates attention
9. Padding and batching	Pad right, mask both the layer and the loss, normalise on training only, sort by length
10. Project	Naive baseline first; LSTM vs GRU on the same split; quantile intervals for honest reporting

The threads running through the course

Order is a variable, and every architectural choice bows to it. Module 1 states it: shuffling a sequence destroys the signal. Module 3 uses it to justify the memory cost. Module 7 uses it to forbid bidirectionality on forecasting. Module 9 uses it to build a leak-free pipeline. The single question "what does the model know at prediction time?" answers most design decisions.

Long-range dependencies are an architectural problem, not a hyperparameter one. Module 4 shows why: the BPTT gradient is a product of matrices. Adding more units, more epochs or more data does not change the product; only replacing it with the additive path of an LSTM (module 5) or the update-gate path of a GRU (module 6) does. When even those saturate, attention (course 12) is the next architectural step, not a bigger recurrent layer.

The pipeline is where most projects actually fail. Module 9 is the least glamorous module of the course and possibly the most important. A shuffled split (module 1), a bidirectional pass on the horizon (module 7), a scaler fitted on the whole series (module 9), a missing mask on the loss (module 9), an overlapping window across a boundary (modules 1 and 9): each one, alone, invalidates a project. The final project (module 10) is essentially the pipeline plus modest models.

A single number is a promise you cannot keep. Module 10 introduces the pinball loss and prediction intervals for exactly that reason. Operations plans capacity on the interval, not on the point forecast. Reporting a single MAE without a spread, or a single seed without a variance, transfers uncertainty from the model to the decision-maker without warning them.

The final exam

The exam has 40 questions covering all ten modules: the difference between a sequence and a table, the correct split for a forecasting task, the shape of a (batch, time, features) tensor, the effect of return_sequences, the memory cost of BPTT, the meaning of a vanishing gradient diagnosis, the reason a forget-gate bias is initialised to 1, the parameter counts of an LSTM and a GRU on the same problem, the situations where a bidirectional layer is safe and where it is a leakage bug, the role of teacher forcing and of <sos> / <eos> in an encoder-decoder, the correct use of padding and masking, and the honest way to report an interval forecast.

Several questions are situational: a validation loss that plummets to numbers no one can reproduce, a training loss that occasionally becomes NaN, a translation that always outputs the same sentence, a stacked model that refuses to compile because of a missing flag, a naive baseline that beats a 300 000-parameter LSTM. Judgement is what gets assessed, not memorised layer names.

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

The bridge to course 12

The encoder-decoder of module 8 works well up to a few dozen source tokens and degrades on long ones. Bahdanau's fix — let the decoder look back at every encoder state, weighted by relevance — is called attention, and it grew into the Transformer, which now dominates most sequence work.

Course 12 picks up the story from there: how attention is computed, why "attention is all you need", and how the fixed-context bottleneck of module 8 becomes a dynamic, learned context that scales to thousands of tokens.

Before you start

Reread 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 shuffled split flatters a forecasting model, why a SimpleRNN reliably fails past 100 steps, why a bidirectional layer is safe on NER but forbidden on the electricity horizon, and why a point forecast without an interval is dishonest, 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.