Skip to main content

Practice exam · GCP

Google Cloud Professional Machine Learning Engineer practice exam

50
questions
120
minutes
70%
to pass the practice exam
60
questions in the bank

Short answer

The Google Cloud Professional Machine Learning Engineer practice exam has 50 questions in 120 minutes, with a 70% passing mark, as configured here. The fastest way to know whether you are ready is to sit a full exam on the clock and read your score by domain, not only the total.

Domains covered

  • ML Model Development
  • ML Data Preparation and Processing
  • ML Pipeline Automation and Orchestration
  • ML Problem Framing
  • ML Solution Monitoring and Maintenance

Sample questions, with explanations

Three questions from the bank, open to read.

Question 1 · ML Data Preparation and Processing

A data scientist standardizes (z-score) and applies log transforms to numeric features in pandas BEFORE calling train_test_split, then reports strong cross-validation results. A reviewer flags a methodology flaw. What is the precise problem and remedy?

  1. Statistics for scaling were fit on the full dataset including validation/test rows, leaking distribution info; fit the transform on training folds only and apply the fitted parameters to validation/test (e.g., via a pipeline). ✓ (correct)
  2. Log transforms are invalid for any ML model, so removing them will fix the inflated metrics.
  3. train_test_split must always precede loading data into pandas, so the only fix is to split inside BigQuery first.
  4. The features should have been one-hot encoded before scaling; reordering encoding before scaling removes the leakage.
Why this is correct

The correct answer pinpoints preprocessing leakage: computing scaling statistics (mean/std) over ALL rows before splitting lets the validation/test distribution influence the training transform, so reported metrics are optimistic. The remedy is to fit transforms on training data only and apply the frozen parameters to held-out data, ideally inside a pipeline so each CV fold refits correctly. 'Log transforms are invalid for any ML model' is false — log transforms are a legitimate, common feature transformation; they are not the source of the leakage. 'train_test_split must precede loading into pandas' is a fabricated rule about ordering of tooling, not the actual issue (the issue is WHEN statistics are computed relative to the split). 'One-hot encode before scaling' is irrelevant to the leakage — encoding order does not address statistics being computed across the split boundary.

Question 2 · ML Model Development

A retail analytics team has 18 months of transactional data already sitting in BigQuery (roughly 400 GB). They need a churn-prediction model for a weekly batch scoring job, the analysts are SQL-fluent but have little Python experience, and leadership wants the first working model within two days with minimal data movement. Which training approach best fits these constraints?

  1. Export the BigQuery tables to Cloud Storage as CSV, then write a custom TensorFlow training job and submit it to Vertex AI custom training on a GPU node
  2. Stream the BigQuery rows into Vertex AI Feature Store, then build a custom PyTorch training pipeline orchestrated with Vertex AI Pipelines
  3. Train a logistic regression model directly in BigQuery ML using a CREATE MODEL statement, then run batch predictions with ML.PREDICT against the same dataset ✓ (correct)
  4. Download the data to a Vertex AI Workbench notebook and train a scikit-learn model in-memory on the instance
Why this is correct

Training a logistic regression directly in BigQuery ML is correct because the data is already in BigQuery, the team is SQL-fluent, and BQML lets them train and batch-score with SQL (CREATE MODEL / ML.PREDICT) without moving 400 GB anywhere — meeting the two-day, minimal-movement requirement. Exporting to CSV and writing a custom TensorFlow job on a GPU is wrong: it forces unnecessary data egress, requires Python/TF skills the team lacks, and a GPU is pointless for a simple tabular classifier. Streaming into Feature Store plus a custom PyTorch pipeline is over-engineered for a weekly batch job and adds infrastructure the team can't maintain in two days; Feature Store targets low-latency online serving, not this use case. Downloading the data to a Workbench notebook to train in-memory is wrong because 400 GB will not fit in instance memory and it abandons the in-warehouse advantage entirely.

Question 3 · ML Model Development

A real-time fraud model serves on a Vertex AI endpoint with a g2 GPU. Traffic is bursty: near-zero at night, heavy at midday. Average GPU utilization is 8% but the team provisioned 10 replicas to survive spikes, and the monthly bill is dominated by idle GPUs. They need to cut cost without dropping requests during bursts. Which change best addresses the cost/performance tradeoff?

  1. Set the minimum and maximum replicas both to 10 and rely on a CDN to cache fraud scores.
  2. Enable autoscaling on the endpoint with a low minimum replica count and a GPU/CPU utilization target, so replicas scale up during bursts and down when idle. ✓ (correct)
  3. Keep 10 replicas fixed but switch them to larger GPUs so each request finishes faster.
  4. Move the model to batch prediction jobs scheduled hourly to avoid paying for any online endpoint.
Why this is correct

Autoscaling with a low minimum and a utilization target is correct: it lets the endpoint shed idle GPUs at night (cutting the cost driver) while still adding replicas under midday load, preserving low latency for real-time fraud scoring. Switching to larger GPUs while keeping 10 fixed replicas is wrong because the problem is idle capacity, not per-request speed; bigger GPUs increase the idle bill further. Moving to hourly batch prediction is wrong because fraud scoring is a real-time, per-transaction decision; hourly batches would let fraudulent transactions through before they are scored. Pinning min=max=10 with a CDN is wrong because it removes scaling entirely and CDNs cache static content by key, whereas every fraud request has unique features, so cache hit rate would be near zero and you'd still pay for 10 idle GPUs.

Take the full practice exam

  • 50 questions drawn from the bank, with a 120-minute timer
  • Score by domain and a review of every question
  • An AI tutor to talk through each question you miss
  • What you miss feeds your study plan
Start the practice exam

Independent, unofficial practice exam. GCP and the exam name are trademarks of their owners; UpSkillScore is not affiliated with them. Format and passing mark are the exam's configuration in UpSkillScore, not an official statement.

Frequently asked questions

How many questions does the Google Cloud Professional Machine Learning Engineer practice exam have?

It has 50 questions and a 120-minute limit. The passing mark of the practice exam is 70%.

Is this the official Google Cloud Professional Machine Learning Engineer exam?

No. It is an independent practice exam built to match the structure of the real one. It does not replace the official exam.

Do I need an account to take it?

You can read the structure and sample questions without an account. Taking the full timed exam, scoring by domain and the AI tutor need one.