Introduction

PCA learns a projection from your training data. New samples must be sent through that exact same projection, or their component values will not match the training coordinates and cannot be compared or used safely by a downstream model.

In practical terms, you fit PCA once on the training set and later call transform on new data. If you normalized, standardized, or imputed the training set before PCA, those fitted preprocessing steps must also be reused.

Fit On The Training Set, Then Reuse The Model

Principal Component Analysis finds directions of maximum variance in the training data. Those directions become the component axes. If you fit a new PCA object on incoming data, the axes may shift, so the transformed values live in a different space.

1import numpy as np
2from sklearn.decomposition import PCA
3from sklearn.preprocessing import StandardScaler
4
5X_train = np.array([
6    [1.0, 10.0, 100.0],
7    [2.0, 11.0, 98.0],
8    [3.0, 13.0, 95.0],
9    [4.0, 15.0, 90.0],
10])
11
12X_new = np.array([
13    [2.5, 12.0, 97.0],
14    [3.5, 14.0, 92.0],
15])
16
17scaler = StandardScaler()
18X_train_scaled = scaler.fit_transform(X_train)
19
20pca = PCA(n_components=2)
21X_train_pca = pca.fit_transform(X_train_scaled)
22
23X_new_scaled = scaler.transform(X_new)
24X_new_pca = pca.transform(X_new_scaled)
25
26print(X_train_pca)
27print(X_new_pca)

The important detail is that only the training data goes through fit_transform. New data uses transform so the same means, scales, and component directions are preserved.

Reuse Preprocessing Exactly

PCA is sensitive to feature scale. A feature measured in large units can dominate another feature unless you standardize first. That is why PCA is often paired with StandardScaler.

If the training data was scaled, the new data must go through the already-fitted scaler:

1print("Scaler mean:", scaler.mean_)
2print("Scaler scale:", scaler.scale_)
3print("PCA components:")
4print(pca.components_)

Those learned values define the transformation. If you call fit on the new batch, you are silently creating a different coordinate system.

Prefer A Pipeline In Real Projects

A scikit-learn Pipeline keeps the steps together and prevents accidental refits on inference data.

1import numpy as np
2from sklearn.decomposition import PCA
3from sklearn.pipeline import Pipeline
4from sklearn.preprocessing import StandardScaler
5
6pipeline = Pipeline([
7    ("scale", StandardScaler()),
8    ("pca", PCA(n_components=2)),
9])
10
11X_train = np.array([
12    [1.0, 10.0, 100.0],
13    [2.0, 11.0, 98.0],
14    [3.0, 13.0, 95.0],
15    [4.0, 15.0, 90.0],
16])
17
18pipeline.fit(X_train)
19
20X_new = np.array([
21    [2.5, 12.0, 97.0],
22    [3.5, 14.0, 92.0],
23])
24
25print(pipeline.transform(X_new))

This pattern is especially useful when PCA feeds a classifier or regressor, because the same saved pipeline can be reused later for prediction without manually managing separate objects.

Keep The Feature Schema Stable

Reusing the PCA object is not enough if the feature layout changes. The new data must contain the same columns, in the same order, with the same units and meanings. If one column moves or is encoded differently, the projection is numerically valid but semantically wrong.

That is why production pipelines often validate column names before calling transform. Silent schema drift is one of the hardest PCA bugs to spot because the output still looks like normal numbers.

Common Pitfalls

The biggest mistake is fitting PCA again on the new data. That produces a fresh basis and makes the transformed result incompatible with the training components.

Another common issue is forgetting preprocessing. If training included scaling, missing-value handling, or encoding, the new samples must pass through those same fitted steps before PCA.

A third problem is column mismatch. Even a simple reorder can invalidate the transformed coordinates while leaving no obvious runtime error.

Summary

• Fit PCA on the training set once and reuse it for all future samples.
• Use transform, not fit_transform, on new data.
• Reapply the same fitted scaler or other preprocessing steps.
• A Pipeline is the safest way to keep training and inference consistent.
• Ensure that new data has the same feature columns, order, and units as training data.