Google Cloud Expert

GCP-PMLE

Google Cloud Professional Machine Learning Engineer

The Google Cloud Professional Machine Learning Engineer certification validates the ability to design, build, and productionize machine learning models to solve business challenges using Google Cloud technologies. This certification is designed for ML engineers who leverage their knowledge of machine learning, deep learning, and Google Cloud to build scalable ML solutions.

The exam covers architecting low-code ML solutions using BigQuery ML, AutoML, and pre-trained APIs, collaborating within and across teams to manage data and models, scaling prototypes into ML models using Vertex AI Training and custom training jobs, serving and scaling models using Vertex AI Prediction, Cloud Run, and GKE, and automating and orchestrating ML pipelines using Vertex AI Pipelines, Cloud Composer, and Kubeflow Pipelines.

This certification is recommended for professionals with at least three years of industry experience and one year of hands-on experience designing and managing ML solutions on Google Cloud. It validates the ability to frame business problems as ML problems, prepare and process data for ML, train and tune ML models, deploy models to production, monitor model performance, and implement MLOps practices for continuous model improvement.

Updated Nov 2024 AI & Machine Learning

Questions

Practice Tests

70%

Pass Score

Views

Total Attempts

Avg. Score

Pass Rate

Discussions

Practice Tests Flash Cards Exam Topics Cheat Sheet

€5.00

GCP-PMLE Practice Exam 1

Comprehensive 50-question practice exam covering Google Cloud Professional Machine Learning Engineer topics including AutoML, BigQuery ML, Vertex AI, Feature Store, experiment tracking, model versioning, data governance, pipeline orchestration, and model serving at scale.

50 Q 120 minutes 70%

Test Drive

€5.00

GCP-PMLE Practice Exam 2

Second comprehensive 50-question practice exam for the Google Cloud Professional Machine Learning Engineer certification covering AutoML, BigQuery ML, Vertex AI Feature Store, distributed training, model serving, monitoring, and MLOps pipeline automation.

50 Q 120 minutes 70%

Test Drive

€5.00

GCP-PMLE Practice Exam 3

Third comprehensive 50-question practice exam for the Google Cloud Professional Machine Learning Engineer certification covering low-code ML solutions, data management, model prototyping, production serving, and automated ML pipelines.

50 Q 120 minutes 70%

Test Drive

€5.00

GCP-PMLE Practice Exam 4

Fourth comprehensive 50-question practice exam for the Google Cloud Professional Machine Learning Engineer certification covering AutoML solutions, data and model management, scaling ML prototypes, production serving, and pipeline automation.

50 Q 120 minutes 70%

Test Drive

€5.00

GCP-PMLE Practice Exam 5

Fifth practice exam for Google Cloud Professional Machine Learning Engineer certification. Covers advanced low-code ML solutions, data management and model collaboration, scaling prototypes to production, serving and scaling models, and automating ML pipelines with 50 scenario-based questions.

50 Q 120 minutes 70%

Test Drive

€5.00

GCP-PMLE Practice Exam 6

Sixth practice exam for Google Cloud Professional Machine Learning Engineer certification. Covers advanced low-code ML solutions, data management and model collaboration, scaling prototypes to production, serving and scaling models, and automating ML pipelines with 50 scenario-based questions.

50 Q 120 minutes 70%

Test Drive

Unlock All Content for GCP-PMLE

6 Practice Test(s) + Flash Cards — 3 months access

€39.99 €26.99 Save 30%

or included with Monthly subscription / Content Bundle

GCP-PMLE Cheat Sheet

Quick reference guide - 6 sections

Free Access

Translating Business Problems into ML Problems

Before reaching for Vertex AI, confirm that ML is the right tool. A business problem is a good ML candidate when decisions must be made at scale, patterns are too complex to hand-code, and labeled data (or a path to labels) exists. If a simple rule-based heuristic delivers ≥ 90% of the value, skip ML.

Stakeholder interview: capture the business KPI (e.g., reduce churn by 5%).
Proxy label: pick a measurable target that correlates with the KPI.
Unit of prediction: user, session, transaction, image, sentence.
Decision boundary: what action is taken on a positive prediction?
Feasibility check: baseline with a heuristic before investing in ML.

Types of ML Problems

Supervised

Labeled input/output pairs. Further split into:

Classification (discrete labels) – spam detection, image tags
Regression (continuous values) – price forecasting, ETA
Ranking – recommendation, search relevance

Unsupervised

No labels; find structure.

Clustering – K-means, DBSCAN (BigQuery ML K-MEANS)
Dimensionality reduction – PCA, UMAP, autoencoders
Anomaly detection – isolation forest, one-class SVM

Reinforcement Learning

Agent learns from rewards via environment interaction.

Used for robotics, bidding, game play
TF-Agents library on Vertex AI Custom Training
Typically long training horizons; careful with reward hacking

Choosing Success Metrics

Problem	Primary Metric	When to use
Binary classification (balanced)	Accuracy, AUC ROC	Classes roughly equal, threshold flexible
Binary classification (imbalanced)	Precision, Recall, F1, PR-AUC	Fraud, medical positives are rare
Multi-class	Macro/Weighted F1, Top-k accuracy	Many classes, varying frequency
Regression	RMSE, MAE, MAPE, R²	RMSE penalizes large errors; MAE robust to outliers
Ranking/Recommender	NDCG, MAP, Recall@K, MRR	Top-k quality matters more than overall
Probabilistic forecasting	Log-loss, Brier score, pinball	Calibrated probability required

Pro tip: Always define a business proxy metric (revenue, churn delta) and tie the technical metric to it. Vertex AI Experiments lets you log both.

Data Sources on Google Cloud

BigQuery – analytical warehouse, native ML (BQML), federated queries to Spanner/Cloud SQL.
Cloud Storage (GCS) – raw files (CSV, JSONL, Parquet, TFRecord, images, audio).
Cloud SQL / Spanner – OLTP sources for features; use Datastream to replicate to BigQuery.
Pub/Sub – streaming ingestion for real-time features.
Bigtable – low-latency feature serving (sub-10ms) for high QPS.
Firestore / Firebase – mobile/web event streams.

Exploratory Data Analysis (EDA)

Vertex AI Workbench (user-managed/managed notebooks) for pandas, seaborn, TFDV.
TensorFlow Data Validation (TFDV) computes statistics, infers schema, detects anomalies & skew.
Facets (Overview, Dive) for visual exploration.
BigQuery APPROX_QUANTILES, COUNTIF, CORR for quick stats on TB-scale data.

import tensorflow_data_validation as tfdv
stats = tfdv.generate_statistics_from_csv('gs://bucket/train.csv')
schema = tfdv.infer_schema(stats)
tfdv.display_schema(schema)
# Detect training/serving skew
serving_stats = tfdv.generate_statistics_from_csv('gs://bucket/serving.csv')
anomalies = tfdv.validate_statistics(serving_stats, schema)
tfdv.display_anomalies(anomalies)

Data Quality & Cleaning Checks

Missing values: imputation (mean/median/mode, KNN, model-based).
Outliers: IQR, z-score, isolation forest.
Duplicates: BigQuery ROW_NUMBER() + partition keys.
Class imbalance: SMOTE, class weights, focal loss, down/upsampling.

Label leakage: features created after the label point-in-time.
Time-aware splits for temporal data (never random shuffle).
Stratified sampling to preserve label distribution.
PII scrubbing via Cloud DLP before training.

Quick gcloud & Python Reference

# Upload a dataset to Cloud Storage
gsutil -m cp -r ./data gs://my-bucket/raw/

# Create a BigQuery dataset for ML
bq --location=US mk --dataset my-project:ml_features

# Train a logistic regression directly in BigQuery
bq query --use_legacy_sql=false '
CREATE OR REPLACE MODEL ml_features.churn_lr
OPTIONS(model_type="LOGISTIC_REG", input_label_cols=["churn"]) AS
SELECT * FROM ml_features.customer_training;'

Feature Engineering Fundamentals

Feature engineering is often the highest-leverage activity in an ML project. On GCP, transformations can live in BigQuery SQL, Dataflow (Apache Beam), Dataproc (Spark), Dataprep (Trifacta), or the TFX Transform component for training/serving parity.

Numerical scaling: min-max, z-score, log, power (Box-Cox, Yeo-Johnson).
Bucketization: equal-width, quantile (tf.feature_column.bucketized_column).
Categorical encoding: one-hot, hash, target/mean, embeddings.
Crossed features: tf.feature_column.crossed_column for feature interactions (e.g., zip × day_of_week).
Text: tokenization, TF-IDF, pretrained embeddings (USE, BERT on Vertex Model Garden).
Images: augmentation (flip, crop, color jitter), resize, normalization.

Choosing a Transformation Tool

Tool	Best for	Notes
BigQuery SQL / BQML	Tabular warehouse data	Petabyte scale, no infra, use `ML.TRANSFORM` for serving parity
Dataflow (Apache Beam)	Batch & streaming unified	Ideal for event data, TFX Transform runs on Dataflow
Dataproc (Spark)	Existing Spark/Hadoop workloads	Lift-and-shift; use Spark MLlib or PySpark
Cloud Dataprep (Trifacta)	Visual, low-code wrangling	Analyst-friendly, generates Dataflow jobs
TFX Transform (tf.transform)	Training/serving parity	Analyzers run once, `transform_fn` graph embedded in SavedModel

TFX Transform Example

import tensorflow_transform as tft

def preprocessing_fn(inputs):
    outputs = {}
    outputs['income_z'] = tft.scale_to_z_score(inputs['income'])
    outputs['age_bucket'] = tft.bucketize(inputs['age'], num_buckets=10)
    outputs['occupation_idx'] = tft.compute_and_apply_vocabulary(
        inputs['occupation'], top_k=500)
    outputs['label'] = inputs['label']
    return outputs

Analyzers (scale_to_z_score, compute_and_apply_vocabulary) run a full-pass Dataflow job during training and bake statistics into the serving graph.

Embeddings & Crossed Features

High-cardinality categoricals → learn dense embeddings (rule of thumb: dim = min(50, cardinality^0.25 * 6)).
Store learned embeddings in Vertex AI Matching Engine (ScaNN) for approximate nearest neighbor serving.
Use pretrained embeddings via TF Hub (USE, BERT) to cold-start text/image models.
Crossed features capture interactions in wide models (Wide & Deep architecture).

Vertex AI Feature Store

Centralized, versioned repository for ML features. Eliminates training/serving skew by serving the exact feature values at low latency online and in batch.

EntityType – logical grouping (e.g., user, product).
Features – versioned numeric/categorical columns with types.
Online store – low-latency Bigtable-backed lookup.
Offline store – BigQuery-backed for training point-in-time joins.
Ingestion – batch from BigQuery/GCS, streaming from Pub/Sub.
Monitoring – drift detection per feature.

from google.cloud import aiplatform
aiplatform.init(project='my-proj', location='us-central1')

fs = aiplatform.Featurestore.create(featurestore_id='retail_fs')
users = fs.create_entity_type('users')
users.create_feature('lifetime_value', value_type='DOUBLE')
users.create_feature('country', value_type='STRING')

# Online serving
values = users.read(entity_ids=['u123','u456'],
                    feature_ids=['lifetime_value','country'])

TFRecord Format & Efficient IO

TFRecord is the preferred binary format for TensorFlow training on Vertex AI. It streams efficiently from GCS, supports sharding, and integrates with tf.data.

feature = {
  'image': tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_bytes])),
  'label': tf.train.Feature(int64_list=tf.train.Int64List(value=[label]))
}
example = tf.train.Example(features=tf.train.Features(feature=feature))
writer.write(example.SerializeToString())

# Read efficiently
ds = tf.data.TFRecordDataset(tf.io.gfile.glob('gs://b/train-*.tfrecord'))
ds = ds.map(parse_fn, num_parallel_calls=tf.data.AUTOTUNE)
ds = ds.shuffle(10000).batch(256).prefetch(tf.data.AUTOTUNE)

Pipeline Tips

Prefer Dataflow over custom GCE for preprocessing — autoscaling, monitoring, streaming ready.
Use Dataflow templates to trigger reusable pipelines from Cloud Composer or Cloud Functions.
Shard TFRecords to ~100MB each for optimal parallel reads.
Validate schema drift with TFDV before every training run.
Always compute statistics on train and eval splits separately to catch distribution skew.

Vertex AI Training Options

AutoML

No-code training for tabular, text, image, video. Use when:

Quick baseline needed
Team lacks deep ML expertise
Labeled data fits supported types
Export to edge (AutoML Edge) for on-device

Custom Training

Full control via Python packages or containers.

Prebuilt containers: TF, PyTorch, XGBoost, scikit-learn, JAX
Custom containers: any framework, push to Artifact Registry
GPU (T4, V100, A100, H100) and TPU (v2/v3/v4/v5e) support

BigQuery ML

SQL-native models trained inside the warehouse.

Linear/logistic regression, DNN, boosted trees, K-means
ARIMA_PLUS for forecasting
Matrix factorization for recommenders
TRANSFORM clause for feature parity

Vertex AI Workbench

User-managed notebooks: GCE-backed JupyterLab, full root, customizable.
Managed notebooks: serverless, idle shutdown, scheduled execution.
Integrated with BigQuery, Cloud Storage, and Git (Cloud Source Repositories).
Use nbconvert --to script + papermill to promote notebooks to production training jobs.

Training Job Tiers & Machine Types

Vertex AI has deprecated named scale tiers (BASIC, STANDARD_1, etc.) in favor of explicit WorkerPoolSpecs. However, legacy scale tier names still appear on exams:

Legacy Tier	Accelerator	Use Case
BASIC	Single CPU VM	Tiny experiments
STANDARD_1	Multi-worker CPUs	Data-parallel CPU training
BASIC_GPU	1x K80/T4 GPU	Small DL models
STANDARD_GPU	Multi-GPU workers	Distributed DL training
BASIC_TPU	1x TPU v2/v3	Large TF/JAX models
CUSTOM	Any WorkerPoolSpec	Fine-grained control

Modern recommendation: specify machine types such as n1-standard-8, a2-highgpu-1g, or cloud-tpu directly in WorkerPoolSpec.

Launching a Custom Training Job

from google.cloud import aiplatform
aiplatform.init(project='my-proj', location='us-central1',
                staging_bucket='gs://my-staging')

job = aiplatform.CustomContainerTrainingJob(
    display_name='churn-xgb',
    container_uri='us-docker.pkg.dev/my-proj/ml/xgb-trainer:1.2',
    model_serving_container_image_uri=
        'us-docker.pkg.dev/vertex-ai/prediction/xgboost-cpu.1-7:latest'
)

model = job.run(
    machine_type='n1-standard-8',
    accelerator_type='NVIDIA_TESLA_T4',
    accelerator_count=1,
    args=['--num_round=200','--max_depth=8'],
    replica_count=1,
    model_display_name='churn-xgb-v3',
    sync=True)

Hyperparameter Tuning with Vertex Vizier

Vizier uses Bayesian optimization, Gaussian Processes, and gradient-free search to efficiently explore hyperparameter space.

from google.cloud.aiplatform import hyperparameter_tuning as hpt

hp_job = aiplatform.HyperparameterTuningJob(
    display_name='churn-hp',
    custom_job=job,
    metric_spec={'auc':'maximize'},
    parameter_spec={
        'lr': hpt.DoubleParameterSpec(min=1e-4, max=1e-1, scale='log'),
        'max_depth': hpt.IntegerParameterSpec(min=3, max=12, scale='linear'),
        'optimizer': hpt.CategoricalParameterSpec(values=['adam','sgd'])
    },
    max_trial_count=40,
    parallel_trial_count=4,
    search_algorithm=None  # default Bayesian
)
hp_job.run()

Use early stopping to kill unpromising trials.
Log metrics via hypertune library.
Parallel trials speed wall-clock; too high dilutes Bayesian signal.
Prefer log scale for learning rate and regularization params.

Distributed Training Strategies

Strategy	Topology	When
`MirroredStrategy`	Single host, many GPUs	Most common; data-parallel synchronous
`MultiWorkerMirroredStrategy`	Multi host, many GPUs	Scale beyond one VM with all-reduce
`TPUStrategy`	TPU pod	Massive models, XLA-compatible ops
`ParameterServerStrategy`	Ps + workers	Asynchronous, huge embeddings
`CentralStorageStrategy`	Single host CPU+GPUs	Variables on CPU, ops on GPU

strategy = tf.distribute.MirroredStrategy()
with strategy.scope():
    model = build_model()
    model.compile(optimizer='adam', loss='bce', metrics=['AUC'])
model.fit(train_ds, epochs=20, validation_data=val_ds)

Experiment Tracking

Vertex AI Experiments – tracks runs, params, metrics, artifacts.
Vertex AI TensorBoard – hosted TensorBoard with IAM controls.
Log via aiplatform.log_metrics({'auc': 0.92}).
Compare runs with aiplatform.Experiment.get_data_frame().

MLOps Maturity Levels

Google's MLOps white paper defines three maturity levels:

Level 0: Manual

Scripts, notebooks, manual model upload. No CI/CD, no monitoring. Retraining = a human runs a notebook.

Level 1: ML Pipeline Automation

Automated training pipeline, experiment tracking, metadata store, continuous training triggered on data/code changes.

Level 2: CI/CD Automation

Full CI (unit & integration tests), CD (deploy endpoints), CT (continuous training). Cloud Build + Vertex AI Pipelines.

Vertex AI Pipelines

Serverless Kubeflow/TFX pipeline runtime. Authors define DAGs in Python using Kubeflow Pipelines SDK v2 (KFP) or TFX, compile to JSON, and submit.

Each step runs as a container on Vertex AI managed compute.
Metadata and lineage stored in Vertex ML Metadata (backed by Cloud SQL).
Built-in components: CustomTrainingJobOp, EndpointCreateOp, ModelDeployOp, BatchPredictionJobOp, AutoMLTabularTrainingJobRunOp.
Triggered by Cloud Scheduler, Pub/Sub, Cloud Functions, or Cloud Build.

from kfp import dsl, compiler
from google_cloud_pipeline_components.v1 import custom_job, endpoint, model

@dsl.pipeline(name='churn-ct')
def pipeline(project: str, region: str):
    train = custom_job.CustomTrainingJobOp(
        project=project, location=region,
        display_name='train',
        worker_pool_specs=[...])
    upload = model.ModelUploadOp(
        project=project, location=region,
        display_name='churn-model',
        unmanaged_container_model=train.outputs['model'])
    ep = endpoint.EndpointCreateOp(project=project, location=region,
                                    display_name='churn-ep')
    model.ModelDeployOp(endpoint=ep.outputs['endpoint'],
                        model=upload.outputs['model'],
                        dedicated_resources_machine_type='n1-standard-4')

compiler.Compiler().compile(pipeline, 'churn_ct.json')
aiplatform.PipelineJob(display_name='churn-ct',
    template_path='churn_ct.json').submit()

TFX vs. KFP v2

Aspect	TFX	KFP v2
Focus	End-to-end TF pipelines	General ML DAGs, any framework
Components	ExampleGen, Transform, Trainer, Evaluator, Pusher	Python functions or containers
Metadata	ML Metadata (MLMD)	Vertex ML Metadata
Best for	TF-heavy orgs, validation & skew detection	Polyglot teams, custom logic

CI/CD with Cloud Build

Source in Cloud Source Repositories, GitHub, or GitLab.
Cloud Build triggers on push/PR; cloudbuild.yaml runs tests, builds containers, pushes to Artifact Registry.
Separate triggers for CI (tests + build), CD (promote to staging/prod endpoint), CT (scheduled retraining).
Use Cloud Deploy for progressive delivery across environments.

# cloudbuild.yaml
steps:
  - name: python:3.10
    entrypoint: bash
    args: ['-c', 'pip install -r requirements.txt && pytest tests/']
  - name: gcr.io/cloud-builders/docker
    args: ['build','-t','us-docker.pkg.dev//ml/trainer:','.']
  - name: gcr.io/cloud-builders/docker
    args: ['push','us-docker.pkg.dev//ml/trainer:']
  - name: gcr.io/cloud-builders/gcloud
    entrypoint: python
    args: ['submit_pipeline.py','--image=us-docker.pkg.dev/$PROJECT_ID/ml/trainer:$COMMIT_SHA']

Vertex Model Registry

Centralized, versioned model catalog with aliases (e.g., @production, @candidate).
Models carry container spec, evaluation artifacts, lineage back to pipeline runs.
Promote via Python SDK or gcloud ai models.
Deploy any version to an endpoint; endpoint traffic split enables A/B and canaries.

model = aiplatform.Model.upload(
    display_name='churn-model',
    artifact_uri='gs://my-bucket/model/',
    serving_container_image_uri='us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-12:latest',
    version_aliases=['candidate'])

# Later, after validation
model.version_aliases = ['production']
model.update_version()

Continuous Training Triggers

Cloud Scheduler → Pub/Sub → Cloud Function → PipelineJob.submit() for time-based CT.
Eventarc on GCS object.finalize to retrain when new data lands.
Vertex AI Model Monitoring drift alerts -> Pub/Sub -> retraining pipeline.

Cloud Build trigger on main merge for CI.
Manual approval gate before promoting to production endpoint.
Record metrics + lineage in Vertex ML Metadata for auditability.

Testing the Pipeline

Unit tests: preprocessing functions, model.predict shapes.
Data validation: TFDV schema check before training step runs.
Model validation: new model must beat baseline on eval metric + fairness.
Integration tests: small-sample pipeline end-to-end in a test GCP project.
Infrastructure tests: canary deploy + rollback on failing health check.

Online vs. Batch Prediction

Online Prediction

Low latency (<100 ms p95 typical).
Deploy Model to Endpoint, choose machine type + accelerators.
Autoscaling via min_replica_count / max_replica_count.
Private endpoints via PSC for low-latency VPC access.

Batch Prediction

High-throughput over GCS/BigQuery input.
No endpoint required; job runs on ephemeral workers.
Ideal for nightly scoring of millions of rows.
Output to GCS (JSONL/CSV) or BigQuery table.

Deploying to an Endpoint

from google.cloud import aiplatform
aiplatform.init(project='my-proj', location='us-central1')

endpoint = aiplatform.Endpoint.create(display_name='churn-ep')
model = aiplatform.Model('projects/.../models/1234@production')

endpoint.deploy(model=model,
                deployed_model_display_name='churn-v3',
                machine_type='n1-standard-4',
                min_replica_count=1,
                max_replica_count=5,
                traffic_split={'0':100})

# Predict
resp = endpoint.predict(instances=[{'age':35,'income':72000}])
print(resp.predictions)

Traffic Splitting & A/B Testing

A single Vertex endpoint can host multiple DeployedModels. Adjust traffic_split to canary a candidate.

# 90% prod, 10% canary
endpoint.deploy(model=new_model,
                deployed_model_display_name='churn-v4-canary',
                traffic_split={'old_id':90, '0':10})
# Promote after evaluation
endpoint.update_traffic_split({'new_id':100,'old_id':0})

Pair with Cloud Logging to capture request/response for offline eval.
Use Vertex AI Experiments to record A/B business outcome metrics.

Vertex AI Model Monitoring

Continuously compares live traffic features to a training baseline to detect skew and drift.

Training-serving skew: distribution difference between training data and recent requests (uses Jensen-Shannon divergence for numeric, L-infinity for categorical).
Prediction drift: distribution change over time in serving features vs. a previous window.
Feature attribution skew/drift: changes in Shapley values indicate concept drift.
Alert thresholds per feature; alerts route via Pub/Sub or email.

from google.cloud.aiplatform import model_monitoring as mm

obj = mm.ObjectiveConfig(
  skew_detection_config=mm.SkewDetectionConfig(
      data_source='bq://my-proj.ml.train_v3',
      skew_thresholds={'age':0.3,'income':0.2},
      target_field='churn'),
  drift_detection_config=mm.DriftDetectionConfig(
      drift_thresholds={'age':0.2,'income':0.2}))

aiplatform.ModelDeploymentMonitoringJob.create(
  display_name='churn-mon',
  endpoint=endpoint.resource_name,
  logging_sampling_strategy={'random_sample_config':{'sample_rate':0.2}},
  schedule_config={'monitor_interval':'3600s'},
  model_deployment_monitoring_objective_configs=[obj])

Explainable AI

Supported methods: Sampled Shapley (tabular), Integrated Gradients (differentiable models), XRAI (images).
Configured at upload time via explanation_spec; served by endpoint.explain().
Returns per-feature attributions and a baseline (e.g., median/mean).
Attribution drift is a leading indicator of concept drift.

from google.cloud.aiplatform.explain import ExplanationParameters, ExplanationMetadata

params = ExplanationParameters({'sampled_shapley_attribution':{'path_count':25}})
meta = ExplanationMetadata(
    inputs={'features': {'input_tensor_name':'features'}},
    outputs={'churn_prob': {'output_tensor_name':'probabilities'}})

aiplatform.Model.upload(
  display_name='churn-xai',
  artifact_uri='gs://bucket/model/',
  serving_container_image_uri='.../tf2-cpu.2-12:latest',
  explanation_parameters=params,
  explanation_metadata=meta)

Serving Optimizations

TensorFlow SavedModel with signatures for batched inference.
Optimized TensorFlow Runtime (OTRT) on Vertex for up to 6x latency reduction.
NVIDIA Triton custom container for multi-framework, GPU batching.
Quantization (INT8) and XLA compilation for throughput.

Private endpoints with PSC to stay off the public internet.
Enable request/response logging (sampled) to BigQuery.
For edge: export to TFLite, deploy via Coral / Android / iOS.
For huge LLMs: use Vertex AI Model Garden + dedicated endpoints with A100/H100.

Handy gcloud Commands

# List endpoints
gcloud ai endpoints list --region=us-central1

# Deploy a model
gcloud ai endpoints deploy-model ENDPOINT_ID \
  --region=us-central1 --model=MODEL_ID \
  --display-name=churn-v3 --machine-type=n1-standard-4 \
  --min-replica-count=1 --max-replica-count=5 --traffic-split=0=100

# Batch predict
gcloud ai batch-predictions create \
  --region=us-central1 --display-name=nightly-scoring \
  --model=MODEL_ID --job-display-name=scoring \
  --instances-format=bigquery \
  --bigquery-source-input-uri=bq://proj.ds.to_score \
  --predictions-format=bigquery \
  --bigquery-destination-output-uri=bq://proj.ds.scored

Responsible AI Principles

Google's AI Principles require that ML systems be socially beneficial, fair, safe, accountable, and privacy-preserving. Operationalize them through measurement, documentation, and review.

Identify sensitive attributes (gender, race, age, geography) and protected subgroups.
Evaluate performance per subgroup, not only in aggregate.
Define acceptable gaps up front with stakeholders (e.g., equal opportunity within 5%).
Document model decisions and limitations for downstream users.

Fairness Metrics

Metric	Definition	When to use
Demographic parity	Positive rate equal across groups	Advertising, outreach targeting
Equal opportunity	TPR equal across groups	Loans, healthcare screening
Equalized odds	TPR and FPR equal	Criminal justice, strict fairness
Predictive parity	Precision equal across groups	Risk scoring
Calibration	Predicted prob = empirical prob	Pricing, probability downstream

Note: Impossibility theorem — you cannot satisfy demographic parity, equalized odds, and calibration simultaneously for unequal base rates. Pick the metric that matches the use case.

Model Cards & Documentation

Model Cards document intended use, limitations, evaluation results by subgroup, and ethical considerations. Generated via Vertex AI Model Cards Toolkit or model-card-toolkit library.

import model_card_toolkit as mct

toolkit = mct.ModelCardToolkit('gs://my-bucket/model-cards/')
card = toolkit.scaffold_assets()
card.model_details.name = 'Churn Predictor v3'
card.model_details.overview = 'Predicts 30-day churn for retail users.'
card.considerations.ethical_considerations = [
    mct.Risk(name='Fairness gap',
             mitigation_strategy='Monitor TPR diff < 5% per country')]
card.quantitative_analysis.performance_metrics = [
    mct.PerformanceMetric(type='AUC', value='0.91', slice='overall'),
    mct.PerformanceMetric(type='AUC', value='0.88', slice='country=BR')]
toolkit.update_model_card(card)
toolkit.export_format()  # HTML model card

What-If Tool & Fairness Indicators

What-If Tool (WIT): interactive analysis in notebooks; counterfactuals, per-slice performance, PR curves.
Fairness Indicators: TensorFlow library computing sliced metrics (FPR, FNR, accuracy) with confidence intervals.
Integrate in TFX Evaluator to block model promotion on fairness regression.

Privacy & Data Governance

Cloud DLP: inspect and de-identify PII (hash, mask, redact, format-preserving encryption).
Differential privacy: TensorFlow Privacy DP-SGD for training on sensitive datasets.
Federated learning: TFF for on-device training without raw data egress.
Data Catalog + Dataplex: discover, classify, and govern ML datasets.

VPC Service Controls: perimeter around Vertex AI, BigQuery, GCS; blocks data exfiltration.
CMEK (Customer Managed Encryption Keys) via Cloud KMS for models, datasets, endpoints.
IAM least privilege: separate roles/aiplatform.user from roles/aiplatform.admin.
Access Transparency + Audit Logs for who-did-what tracking.

Recommender Best Practices

Use Recommendations AI (Retail) for turnkey retail use cases.
For custom recommenders: two-tower architecture → embeddings in Vertex AI Matching Engine for millisecond ANN lookup.
Combat popularity bias with exposure weighting or IPS.
Monitor feedback loops: recommendations shape future training data.
Freshness: schedule continuous training to capture trends.

Security Checklist

Store container images in Artifact Registry with Binary Authorization enforcing signed images.
Use Workload Identity Federation for cross-cloud CI without static keys.
Encrypt training data in GCS buckets using CMEK; enable Bucket Lock for compliance retention.
Enforce VPC-SC perimeters around Vertex AI APIs when handling regulated data.
Rotate service account keys; prefer short-lived credentials via IAM.
Scan notebooks for secrets with Secret Manager integration; never commit keys.

Exam-Ready Quick Wins

TFX Transform → training/serving parity (avoids skew).
Vertex Feature Store → centralized, low-latency features with drift monitoring.
Vertex Pipelines + Cloud Build → MLOps level 2 (CI/CD/CT).
Endpoint traffic split → canary and A/B without code changes.
Model Monitoring skew & drift + attribution drift → proactive retraining.
Explainable AI: Sampled Shapley (tabular), Integrated Gradients (differentiable), XRAI (images).
VPC-SC + CMEK + DLP → security & privacy trifecta.
Model Cards & Fairness Indicators → Responsible AI documentation.

# Initialize Vertex AI SDK (memorize!)
from google.cloud import aiplatform
aiplatform.init(project='PROJECT', location='us-central1',
                staging_bucket='gs://my-staging',
                experiment='churn-exp',
                encryption_spec_key_name='projects/.../cryptoKeys/k')

GCP-PMLE

Google Cloud Professional Machine Learning Engineer

GCP-PMLE Practice Exam 1

GCP-PMLE Practice Exam 2

GCP-PMLE Practice Exam 3

GCP-PMLE Practice Exam 4

GCP-PMLE Practice Exam 5

GCP-PMLE Practice Exam 6

Unlock All Content for GCP-PMLE

Preview (10 / 120)

Flash Cards

Available Languages

Exam Topics

GCP-PMLE Cheat Sheet

Translating Business Problems into ML Problems

Types of ML Problems

Supervised

Unsupervised

Reinforcement Learning

Choosing Success Metrics

Data Sources on Google Cloud

Exploratory Data Analysis (EDA)

Data Quality & Cleaning Checks

Quick gcloud & Python Reference

Feature Engineering Fundamentals

Choosing a Transformation Tool

TFX Transform Example

Embeddings & Crossed Features

Vertex AI Feature Store

TFRecord Format & Efficient IO

Pipeline Tips

Vertex AI Training Options

AutoML

Custom Training

BigQuery ML

Vertex AI Workbench

Training Job Tiers & Machine Types

Launching a Custom Training Job

Hyperparameter Tuning with Vertex Vizier

Distributed Training Strategies

Experiment Tracking

MLOps Maturity Levels

Level 0: Manual

Level 1: ML Pipeline Automation

Level 2: CI/CD Automation

Vertex AI Pipelines

TFX vs. KFP v2

CI/CD with Cloud Build

Vertex Model Registry

Continuous Training Triggers

Testing the Pipeline

Online vs. Batch Prediction

Online Prediction

Batch Prediction

Deploying to an Endpoint

Traffic Splitting & A/B Testing

Vertex AI Model Monitoring

Explainable AI

Serving Optimizations

Handy gcloud Commands

Responsible AI Principles

Fairness Metrics

Model Cards & Documentation

What-If Tool & Fairness Indicators

Privacy & Data Governance

Recommender Best Practices

Security Checklist

Exam-Ready Quick Wins