Free Google Professional-Machine-Learning-Engineer Actual Exam Questions

I’m thinking A is cleanest since it skips file transfers entirely and directly loads data into pandas. A

Actually, A makes the most sense if your notebook environment already has the needed permissions; it’s the quickest way to get data into pandas without manual file handling. Options B, C, and D add unnecessary overhead.

I think D makes the most sense here. Using feature attributions gives a deeper insight into drift while lowering the prediction-sampling-rate near 0 means much less data is monitored overall, which should save costs despite the extra overhead of attributions. The key is balancing fewer samples with more detailed monitoring, and D nails that better than just tweaking frequency or sampling rates alone.

D, sampling rate near 0 reduces data volume, saving cost despite extra attribution overhead.

C imo. Collaborative filtering is the classic choice for recommendations based on user similarity and purchase behavior, even if ratings aren’t explicit. It naturally captures patterns in user interactions.

C/D? Collaborative filtering fits the user similarity part, but if we just have purchase amounts or frequencies, regression might help predict preferences too. Depends on what data is really available.

Good point on Cloud SQL handling regional data and ANSI-2011 compliance. I’d say C fits best since Pub/Sub or Datastore won’t provide the SQL interface needed, and Cloud Functions might struggle with scaling to that volume. C it is.

Maybe C since Dataflow can scrub PII well and Cloud SQL keeps data regional.

A/D? Increasing batch size (A) can reduce gradient noise, which smooths out loss oscillations, while decreasing learning rate (D) helps prevent overshooting. Both can help, but larger batches give steadier gradients.

If the loss is bouncing around, it usually points to the learning rate being too high rather than batch size issues. Lowering the learning rate (D) lets the model take smaller, more controlled steps, which helps it settle down. Increasing batch size (A) can reduce noise but might not fix oscillations caused by a too-large step. So maybe focusing on tuning the learning rate makes more sense here? Could the oscillations also be from extremely noisy gradients or just a poorly scaled learning rate?

A/D? Data Fusion’s GUI could speed up development with less coding, but might not handle very large scale as efficiently as BigQuery. Since the data’s in Cloud Storage already, loading into BigQuery (D) seems cleaner for serverless SQL.

Option D, since BigQuery handles massive data natively and removes cluster management hassles.

Maybe B could work if you want a big speed boost, but since the code isn’t set up for multi-GPU, it might not use all 8 efficiently. D’s just beefier CPU, so probably slower than GPU options.

It’s C since pre-installed GPU support beats manual setup and unoptimized multi-GPU use.

D imo, completely balancing the classes by removing negatives can make the training much simpler and faster, especially when positives are so rare. Sure, you lose some data, but it avoids the complexity of carefully tuning weights or generating synthetic samples. Sometimes straightforward equal sampling helps models converge better by not overwhelming them with negatives. Plus, with less data, training might be quicker, letting you experiment more. The key is to keep enough negatives while making the dataset manageable and balanced for the model to learn meaningful patterns.

C. Downsampling negatives and upweighting positives strikes a good balance without losing too much info, unlike D that drops too many negatives or A which could add noisy synthetic data. Makes the model focus on real failure signals.

Maybe D, since INFORMATION_SCHEMA is always available without extra setup needed.

Maybe D could work here too, since INFORMATION_SCHEMA tables give you metadata about all your BigQuery tables. You can run queries to list table names and details across datasets without needing extra tools or setup. It’s more manual than Data Catalog but might be useful if you want a quick snapshot or don’t have Data Catalog fully set up yet.

Also, it doesn’t rely on external indexing or tagging, just the metadata that’s already there, so it can be pretty straightforward for finding tables by name or basic info. It’s not as user-friendly for searching descriptions, but definitely an option

The question highlights autoscaling and monitoring for online predictions, so B fits best.

B/D? B nails scheduled retraining and deployment with autoscaling, but D covers custom containers for training too. If Docker’s needed just for deployment, B fits better; otherwise, D could be the safer bet.

D imo, distributing the training across multiple GPUs or nodes should cut time significantly without risking compatibility issues like with TPUs. Plus, more memory alone (A) won’t speed up GPU-bound tasks much.

B/D? I’m thinking D makes more sense here since the setup only has one GPU, so scaling out with tf.distribute.Strategy would speed things up. Also, the question doesn’t confirm TPU support or that the code can run on TPU, so swapping to a v3-32 TPU might cause compatibility issues or need code changes. Increasing memory alone (A) won’t help much without more GPUs or better parallelism. Early stopping (C) might reduce training time but risks hurting model performance, which the question says we don’t want. So D should be the best bet if distributed training is implemented.

B. Cloud Composer can automate the whole training pipeline, including multiple runs, but it doesn’t inherently provide a dashboard for comparing metrics. You’d still need to integrate with another tool for visualization. That makes it less straightforward for the question’s goal of having one place to compare models.

C is tempting since AI Platform supports multiple jobs, but managing and comparing many jobs manually can get messy without a proper experiment tracking setup, which Kubeflow offers natively.

It’s A because AutoML Tables lets you easily try different models and provides a dashboard to compare metrics all in one place, which fits the need for exploring multiple architectures and tracking results.

B. Since the goal is to find articles similar to the one currently being read, using vector embeddings and similarity makes the most sense. Collaborative filtering (A) depends on user history, which might not help when a user reads new topics. Logistic regression for each user (C) seems impractical given the variety of users and articles. Manually labeling articles (D) is too time-consuming and focuses on categories, not similarity, so B still fits best here.

It’s B, since vector similarity directly measures article closeness without needing user data.

D imo, increasing batch size usually helps utilize multiple GPUs better.

I’m thinking option A might be worth reconsidering. If the dataset isn’t properly sharded across the GPUs, each GPU could be doing the same work, so no speedup happens. Distributing the dataset explicitly makes sure each GPU processes a different slice. Just switching to MirroredStrategy alone doesn’t automatically handle how data is fed. Could that explain why training time stayed the same? What if they did increase batch size but didn’t shard the data? Would that still cause no improvement?

D imo, Vertex ML Metadata fits the event-based tracking and slicing perfectly.

Probably A since Cloud SQL can store all the stats in one place, making it straightforward to query and compare across years without depending on specific ML tools.