How to Reuse a 100 GB Preprocessing Step in Agent Platform Pipelines

PMLE By islever Editorial Last updated

Short answer

B Use an Agent Platform Pipelines workflow with separate preprocessing and training components, enable caching on the two-hour 100 GB preprocessing component, and run training as Serverless Training custom jobs.

Question

You are building an ML workflow that preprocesses data, trains a model with hyperparameter tuning, and deploys the best model to an Agent Platform endpoint. Your preprocessing step takes two hours and outputs a 100 GB dataset. You run experiments daily with different model architectures using the same preprocessing step. You need to automate this process and optimize the pipeline runs to minimize cost and time. What should you do?
  1. Configure an Agent Platform Pipelines workflow with a single component for the preprocessing and training steps. Use Agent Platform hyperparameter tuning jobs within the component to identify optimal parameters.
  2. Configure an Agent Platform Pipelines workflow with separate components for the preprocessing and training steps. Enable caching on the preprocessing component, and use Agent Platform Serverless Training custom jobs for the training steps. Correct Answer
  3. Configure an Agent Platform Pipelines workflow with separate components for the preprocessing and training steps. Use a Cloud Run function to trigger the pipeline, and configure Agent Platform Serverless Training custom jobs for the training steps.
  4. Configure an Agent Platform Pipelines workflow that starts with an Agent Platform Serverless Training custom job for the preprocessing step. Use a Cloud Run function to launch the hyperparameter tuning job that is triggered when the preprocessed data arrives in Cloud Storage.

Key Takeaways

This item tests whether you understand that pipeline caching operates at component granularity, and the trap is adding external orchestration or merging preprocessing with training instead of isolating the reusable step.

Agent Platform Pipelines component caching lets daily experiments reuse the unchanged two-hour, 100 GB preprocessing step while separate Serverless Training jobs handle each new model architecture; the correct design is option B.

Common mistake: Option A is tempting because it explicitly includes Agent Platform hyperparameter tuning, but combining preprocessing and training in one component means a changed architecture invalidates the whole component, so caching cannot skip the two-hour preprocessing.

Expert Analysis

Where the boundary lies This scenario separates reusable deterministic data preparation from architecture-specific training. Preprocessing is identical every day, takes two hours, and produces 100 GB, while only the model architecture changes. The design question is therefore whether reuse happens at the pipeline component boundary. Agent Platform Pipelines caches at component granularity, so a separate preprocessing component with caching enabled can skip the expensive work when its code and inputs are unchanged, while downstream training components rerun for new architectures.

Why B is the right side Option B keeps preprocessing and training as separate components, enables caching on preprocessing, and uses Serverless Training custom jobs for training. Reviewers make the same point: separating the expensive step lets the pipeline reuse it, whereas merging it with training defeats targeted reuse. The training job can still vary architecture and hyperparameters without invalidating the cached 100 GB preprocessing output.

Why the other letters fail A combines preprocessing and training in one component, so a changed architecture can invalidate the whole component and force the two-hour preprocessing to rerun. C uses separate components and Serverless Training, but a Cloud Run trigger adds orchestration without enabling caching; starting a pipeline is not reusing a pipeline step. D moves preprocessing into a training custom job and adds Cloud Run plus storage-arrival orchestration, increasing complexity without component-level caching. Hyperparameter tuning is not the bottleneck here; repeated preprocessing is.

The decisive split The boundary is between a cached, reusable preprocessing component and designs that recompute or externalize it. That puts the scenario squarely on B's side.

Official Reference

Exam Strategy

When a scenario contains a costly, deterministic step repeated across experiments, look for a pipeline caching control before changing orchestration. Map each requirement to its service: Agent Platform Pipelines for the workflow, component-level caching for reuse, and Serverless Training for training jobs. Eliminate options that merge reusable steps, add external triggers, or move preprocessing outside the pipeline; those add complexity without addressing repeated computation.

Frequently Asked Questions

Why does option B beat option A when both can support hyperparameter tuning?

B isolates the two-hour preprocessing into its own component, so caching can reuse its 100 GB output when only the training architecture changes. A's combined component prevents that targeted reuse because training changes invalidate the component.

Does a Cloud Run trigger reduce pipeline cost or runtime in this scenario?

No. A Cloud Run function only starts the pipeline or tuning job; it does not cache the preprocessing output, so the two-hour preprocessing still runs each day.

What causes Agent Platform Pipelines caching to be bypassed?

Caching is reused only when the component code, inputs, and parameters are unchanged. Changes to preprocessing inputs or code invalidate the cached step, while separate training changes should not.

More PMLE FAQ →

Community Votes

B
100%

100% of anonymous learners picked answer B. Votes are pick records left by other test-takers — they are not the verified answer.

Discussion 2 contributions

Compiled from public community threads and reader submissions, lightly edited for clarity. Handles and vote tallies are shown as recorded, and comments reflect the views of individual contributors.

From public community threads 2

  1. taylz876 👍 1 Answered B
    Similar to Q201 and Q280 Why B is right • Separate components let the pipeline reuse the expensive step. Preprocessing takes two hours and produces 100 GB, and you run it with the same logic every day while only the model architecture changes. With caching enabled on the preprocessing component, a run with unchanged inputs reuses the stored output and skips the two hours. • Serverless training jobs for the training steps only cost money while they run, which keeps the cost down, and each experiment's training reuses the cached data. Why the others are wrong • A: One component for both steps means preprocessing re-runs every time you change the model, wasting two hours and money. • C: Separate components are right, but there's no caching, so preprocessing still re-runs daily. A function trigger doesn't fix that. • D: Launching a tuning job from a function when data arrives complicates the workflow, and it doesn't cache the preprocessing step.
  2. n2183712847 👍 1 Answered B
    Correct answer: B. Separating preprocessing and training enables caching of the expensive two-hour, 100 GB preprocessing step so it can be reused across experiments, while Serverless Training efficiently handles the model training jobs; A prevents effective reuse by combining the steps, C adds an unnecessary Cloud Run trigger without addressing preprocessing reuse, and D adds unnecessary orchestration and storage-trigger complexity.

Reader comments & corrections

No reader corrections yet — spotted an error or have a note? Share it below.

Log in to comment, report an error, or add a note about this question.

Practice All PMLE Questions

Access 65 questions with complete answers and detailed explanations.

View Full PMLE Practice Test →

← Back to PMLE Study Guide