PMLE Scaling Prototypes into ML Models Practice Question

A team is deploying a scikit-learn model to Vertex AI for online prediction. The model requires a custom preprocessing step that scales numerical features using statistics computed from the training set. The preprocessing must be identical between training and serving. The team wants to minimize latency and ensure consistency. What should they do?

⚠ Common exam trap

The trap here is assuming that preprocessing can be handled separately or that the client will send preprocessed data, overlooking the need for a single artifact that guarantees consistency.

Answer choices

Why each option matters

Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.

Correct answer & explanation

✓

Wrap the preprocessing and model into a single scikit-learn Pipeline object, and deploy that pipeline as a custom model on Vertex AI.

Wrapping preprocessing and the model into a single scikit-learn Pipeline ensures that the exact same transformations are applied during both training and serving. This eliminates training-serving skew and simplifies deployment. Vertex AI supports deploying custom models with custom prediction routines, but using a native scikit-learn Pipeline is more straightforward and less error-prone, as it encapsulates all steps and can be serialized as one artifact.

Answer analysis

Option-by-option breakdown

For each option: why learners choose it and why it is or isn't the right answer here.

✓
Wrap the preprocessing and model into a single scikit-learn Pipeline object, and deploy that pipeline as a custom model on Vertex AI.
Why this is correct
A scikit-learn Pipeline encapsulates all preprocessing and the final estimator, ensuring that the exact same transformations are applied during training and serving. Deploying the pipeline as a custom model on Vertex AI guarantees consistency and reduces the risk of training-serving skew, while keeping the serving logic simple.
✗
Use a Vertex AI pipeline to preprocess the data before training, and then deploy the model without preprocessing, assuming the input data at serving time will already be scaled.
Why it's wrong here
This assumes the serving input is pre-scaled, which is rarely true. If the client sends raw features, predictions will be wrong. The preprocessing must be part of the serving graph to ensure consistency. This approach pushes the responsibility to the client, which is error-prone.
✗
Save the scikit-learn model and the scaler as separate artifacts, and in the prediction script, load both and apply the scaler before calling model.predict.
Why it's wrong here
While this can work, it requires custom prediction code and managing two artifacts. Vertex AI custom prediction routines support this, but it adds complexity and potential for mismatch if the scaler is not properly versioned. It also may increase latency due to separate loading, though not necessarily.
✗
Use Vertex AI Feature Store to store the scaled features and serve them online, bypassing the need for preprocessing in the model.
Why it's wrong here
Feature Store is for feature management and serving, but it does not automatically apply training-time scaling transformations. The scaled features would need to be computed and ingested, which adds complexity and does not ensure the same scaling logic is used at serving time for new data.

Go deeper

PMLE Scaling Prototypes into ML Models Practice Question

Why each option matters

Option-by-option breakdown

Related to this question