Data Scaling with MinMaxScaler

A linear model is only as useful as the table of numbers it receives. Before a model can learn anything from the Boston Housing data, the data has to be loaded, divided into parts, rescaled, and expanded into a richer set of columns. This article follows that preparation from start to finish. You will trace each step, predict what it should produce, and then check the result against what the program reports.

The goal is not only to run the code. The goal is to learn how to read each stage, so that when something goes wrong you can tell which step produced the surprising result. Preparation errors often do not crash the program. The table can have the right shape and still contain the wrong values, so knowing where each number came from is the most useful skill here.

The first stage imports three tools from scikit-learn, loads the dataset, and divides it into a training portion and a test portion. Read the code from top to bottom. Every name on the left of an equals sign is a new object created by the step on the right. The split is performed by train_test_split, which receives the input data and the target values together and returns four objects: a training input matrix, a test input matrix, a training target vector, and a test target vector.

The rows of boston.data are the samples and its columns are the features. The split keeps inputs and targets aligned, so every row of X_train still belongs with the matching entry of y_train. Splitting the rows this way is what allows the test portion to play the role of data the model has not seen during preparation.

Before reading the scaling steps, it helps to have a concrete expectation. The training matrix starts with 379 rows and 13 columns. The scaling and expansion steps that follow will change the values and then the number of columns, but the number of rows will stay the same at each stage that transforms the features.

Read the diagram as a sequence of states. Loading produces the full table of samples and features. Splitting divides the rows into two groups and leaves the number of columns alone. Scaling changes the values inside the columns but not their count. Expansion changes the count of columns, which is the stage where the matrix becomes wider.

The source uses MinMaxScaler to rescale the data so that its values lie within a common range. The default range in scikit-learn is 0 to 1, where each feature's smallest training value maps to 0 and its largest training value maps to 1, with other values placed proportionally between them. This matters because the polynomial step multiplies features together. If one feature has values far larger than the others, its products would dominate the new columns. Scaling first puts the original features on comparable footing before they are combined.

The fitted scaler is a single object that carries information from the training data into every later step. The diagram below traces which data is used to compute the minimum and maximum, and how the same fitted object then transforms the test set.

The next stage asks the transformer to create new columns from the existing ones. The degree argument sets the largest number of original features that may be multiplied together in one new column. With degree=2, each output column is either an original feature, a constant, a square of one original feature, or a product of two different original features. The transformer is fitted on the scaled training data, and that same fitted object is then used to transform both the scaled training data and the scaled test data.

The printed shapes show the change in width. The original training matrix has 13 columns and the expanded one has 105. The number of rows stays at 379 because each sample still produces exactly one row; only the description of each sample becomes longer. Each of the 13 original features contributes a square term, and each pair of different features contributes one interaction term. Those interaction terms are the pairwise products of the data.

You can predict the column count before running the code. Let n stand for the number of original features. The count has three parts: one constant column, then the n original columns, then the squares and the distinct pairwise products. The squares contribute n terms, and the distinct pairs contribute $\frac{n(n-1)}{2}$ terms, which together give $\frac{n(n+1)}{2}$.

This expression is a way of checking the count, not a formula printed in the source. Written in full, the total is $1 + n + \frac{n(n+1)}{2}$. Using it as a check protects you from trusting a printed shape you did not understand.

A table of 105 unlabeled numbers is hard to interpret, so the transformer can report which input produced each output. The get_feature_names method returns those labels. The labels are not arbitrary. The first is the constant '1', the next thirteen are the original features named x0 through x12, and the names after those show the squares and products. In the printed output, a caret indicates a square, and a space indicates a product of two features.

The full list follows a regular order. Names beginning with x0 come first, then x1, and so on. For each starting feature, the square comes first and is followed by the products with each later feature. So after x0^{^2} come x0 x1, x0 x2, and continuing through x0 x12. Then the names switch to x1^{^2}, followed by x1 x2 and onward. The printed list in the source wraps across several lines, but this regular pattern lets you predict any name from its position.

Read the diagram as a lookup table. Position 0 is the constant. Positions 1 through 13 are the original features. Position 14 begins the squared and product terms built from the first feature. Because the names record the origin of each column, you can check any coefficient or diagnostic later against the input it came from. The position of a column is enough to find its name, and the name is enough to find its origin.

Preparation errors are easy to make because the shapes often look correct. Consider a variant of the code in which the expansion is applied to the unscaled training data instead of the scaled data. The column count is still 105, so a shape check would pass, but the products would be built from raw values on different scales.