Preparing Feature Matrices for Time Series Models

A time series is a sequence of values recorded in order over time, such as the number of bicycle rentals on each day. Unlike a table of unrelated customers, the position of each observation carries meaning: Tuesday's count comes after Monday's and before Wednesday's. That ordering changes how we should judge a model.

When you evaluate a model on this kind of data, the model should be judged on how well it predicts values it has not seen. In a time series, the unseen values are usually the most recent ones. The practical setup is to split the data into a training part and a test part, fit a model on the first part, score it on the second, and plot both parts together so the result can be inspected.

The split is controlled by one index, n_train. The rows before that index form the training set, and the rows from that index onward form the test set. In the source, n_train is fixed at 184, so the first 184 data points train the model and the remaining points test it.

The split is positional, which means it depends only on where each row sits in the sequence. Nothing is shuffled. Because of that, every training row comes earlier in time than every test row. The test set therefore holds the latest observations, and the model is asked to predict the period that follows what it learned from.

The split is done with slicing. A slice written as features[:n_train] takes every element from the start up to, but not including, index n_train. A slice written as features[n_train:] takes every element from index n_train to the end. The two slices together cover the whole array exactly once, with no overlap and no gap.

The same boundary is applied to the target array. That is what keeps each training row paired with its target value and each test row paired with its target value. If the features were cut at one point and the targets at another, the rows would no longer line up.

The function receives three inputs: a feature array, a target array, and a regressor. It uses n_train to slice both arrays, fits the regressor on the training pair, makes predictions, scores the model on the test pair, and draws the figure. The data moves in one direction, which the diagram below traces from the full inputs to the printed score.

After fitting, the function calls regressor.score on the test pair, X_test and y_test, and prints the result with two decimal places. The R^{^2} score is the number that summarises how well the model predicts the test set.

The important detail is which rows the score sees. It sees only the test rows, which the model was not fitted on. A score computed on the training rows would tell you how well the model fits data it has already learned from, which is a weaker check. A model can look good on its own training rows and still fail on the period that follows.

The printed value is a single number. Use it together with the plot rather than on its own. The plot shows where predictions follow the real values and where they drift, while the score compresses that comparison into one figure.

The plotting code draws four series on one set of axes. The training actual values and the training predictions run over the index range from 0 up to n_train. The test actual values and the test predictions start at n_train and continue for as many points as there are in y_test. Each series has a label, so the legend can tell them apart.

Read the plot from left to right. The left segment, ending at n_train, shows training behaviour. The right segment, beginning at n_train, shows test behaviour. The two halves sit side by side on the same horizontal axis, so you can compare how the model behaves in each period.

The two solid lines show the real values, and the two dashed lines show predictions. Start by checking that the test prediction begins where the test actual values begin, at the boundary n_train. Then check whether it follows their shape. Including the training prediction lets you see whether the model does well on data it learned from as well as on data it has not seen.

Debugging an evaluation function usually means finding the line where a value stops being what you expected. The source's plotting line that sets the tick positions uses len(X). Inside eval_on_features, the names defined locally are X_train, X_test, y_train, y_test, y_pred, and y_pred_train. The parameters are features, target, and regressor.

The name X does not appear in either list. Python therefore looks for it in the surrounding global scope. Whether the function works depends on whether a global variable named X exists when the function is called. The scope diagram separates the names the function defines from the name it borrows.