How to Reuse a 100 GB Preprocessing Step in Agent Platform Pipelines
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
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
- https://cloud.google.com/vertex-ai/docs/pipelines/introduction
- https://cloud.google.com/vertex-ai/docs/training/overview
These links open the official vendor documentation in a new tab.
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?
Does a Cloud Run trigger reduce pipeline cost or runtime in this scenario?
What causes Agent Platform Pipelines caching to be bypassed?
Community Votes
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
-
taylz876 👍 1 Answered BSimilar 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.
-
n2183712847 👍 1 Answered BCorrect 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.
Related Analysis
Practice All PMLE Questions
Access 65 questions with complete answers and detailed explanations.
View Full PMLE Practice Test →