Select Two (Multi-Select) Questions

Set a shorter alerting window

Why wrong: Shorter windows may trigger more alerts, increasing false positives.

Decrease the drift threshold

Why wrong: Decreasing threshold increases sensitivity, leading to more false positives.

Enable feature attribution monitoring

Why wrong: Feature attribution monitoring adds more monitoring, not reducing false positives.

Share notebooks via Colab Enterprise with real-time editing

Why wrong: Sharing notebooks does not enforce version control of data and dependencies.

Allow each team to use their own preferred environment

Why wrong: Different environments lead to unreproducible results.

Always use random seeds for all random operations

Why wrong: Random seeds are not always applicable and can be inconsistent.

Run hyperparameter tuning jobs with a large search space

Why wrong: Larger searches require more trials, increasing cost.

Manually scale up resources during peak times and scale down during off-peak

Why wrong: Manual scaling is not efficient; Vertex AI handles scaling based on job requirements.

Use a larger machine type for training to complete faster

Why wrong: Larger machines cost more; faster completion may not offset cost.

Only keep the latest model version to save storage.

Why wrong: Loses historical versions and reproducibility.

Train models directly in production without tracking.

Why wrong: No versioning or lineage; risky.

Use a separate GCP project for each model version.

Why wrong: Overly complex and not cost-effective.

Use a larger machine type with more memory

Why wrong: Larger machines may not reduce latency if the bottleneck is network or model inefficiency; they increase cost.

Use batch prediction instead of online prediction

Why wrong: Batch prediction is not real-time and typically has higher latency for individual requests.

Enable model caching at the endpoint

Why wrong: Vertex AI Endpoints do not have a built-in caching feature; caching at client side may help but is not a best practice on the endpoint.

Use a larger machine type to reduce the number of workers.

Why wrong: Use a larger machine type to reduce the number of workers — this increases cost per worker and may not reduce overall cost; it could even increase cost if the larger machine is underutilized.

Use TPUs instead of GPUs to accelerate processing.

Why wrong: Use TPUs instead of GPUs to accelerate processing — TPUs are generally more expensive and only beneficial for specific models (e.g., large neural networks); not a general cost-saving measure.

Log all raw prediction inputs and outputs for every request for auditing.

Why wrong: May contain PII and impact performance; sample logging is better.

Always deploy the model in the same environment as training to avoid incompatibility.

Why wrong: While important, the training environment may not have the same serving libraries; use consistent versions but not identical.

Use the default model version alias 'default' for all deployments to simplify updates.

Why wrong: Should use custom aliases for canary testing.

Use batch updates to rebuild the entire index daily.

Why wrong: Batch updates cause downtime and are not real-time.

Increase the number of replicas on the deployed index.

Why wrong: Replicas improve query throughput, not index update frequency.

Use a GPU-powered endpoint for faster indexing.

Why wrong: GPUs are for model inference, not indexing updates.

Use full fine-tuning of all model parameters

Why wrong: Full fine-tuning is computationally expensive and not cost-minimizing.

Use TPU v4 pods for training

Why wrong: TPUs are powerful but typically more expensive than GPU spot instances for fine-tuning; not a cost-minimization strategy.

Increase the number of CPU vCPUs per machine.

Why wrong: CPU increase may not help as much as GPU for deep learning.

Set min_replica_count to 0 to avoid idle instances.

Why wrong: min=0 causes cold starts, increasing latency.

Decrease the number of replicas to reduce resource contention.

Why wrong: Fewer replicas may increase latency due to queuing.

Deploy multiple models and use an ensemble to average predictions

Why wrong: Ensemble does not directly address drift.

Manually review model predictions daily

Why wrong: Manual review is not scalable or automatic.

Monitor prediction errors and flag when confidence is low

Why wrong: This monitors prediction quality, not data drift.

Reduce the size of the file being downloaded.

Why wrong: Reducing file size may help but is not a reliability practice; also may not be feasible.

Increase the machine type for the component.

Why wrong: Machine type affects compute resources, not network timeout; not directly related.

Store batch prediction results in BigQuery.

Why wrong: Not required; you can store in GCS. The question asks for steps, but you could, but it's not among the top three.

Use Cloud Functions to convert images to TFRecord.

Why wrong: Not scalable for 100 TB.

Increase the maximum number of replicas

Why wrong: More replicas improve throughput, not individual request latency.

Use a smaller machine type with less memory

Why wrong: Smaller machine may increase latency due to resource constraints.

Enable autoscaling with a lower target CPU utilization

Why wrong: Lower target triggers more replicas, not reduced latency.

Dataflow job to preprocess data

Why wrong: Data preprocessing is typically part of the training pipeline, not delivery.

Importer component to bring in the model

Why wrong: The model artifact is already produced by the training pipeline; importer is unnecessary.

A/B testing component to split traffic

Why wrong: A/B testing is a more advanced pattern; not required for basic continuous delivery.

Use Vertex AI Experiments to track the traffic split percentages.

Why wrong: Experiments track training runs, not endpoint traffic splits.

Enable Cloud Memorystore to cache identical requests for both models.

Why wrong: Caching is irrelevant for A/B testing traffic splitting.

Use Cloud Monitoring to track custom metrics like conversion rate per model version.

Why wrong: Monitoring is necessary but not a step in traffic splitting; it's a separate activity.

Cloud Functions

Why wrong: Cloud Functions are serverless compute, not for version control.

Vertex AI Model Registry

Why wrong: Model Registry is for models, not notebook code.

Vertex AI Experiments

Why wrong: Experiments track runs, not code versioning.

Compute engine CPU and memory logs for each pipeline step.

Why wrong: Infrastructure logs are detailed but not essential for pipeline observability at a high level.

Online prediction latency and request count from the deployed model endpoint.

Why wrong: Serving metrics are separate from pipeline monitoring.

Use BigQuery scheduled queries to run the training script on a schedule.

Why wrong: BigQuery scheduled queries are for SQL queries, not running ML training jobs.

Use AI Platform Notebooks to schedule the training job on a recurring basis.

Why wrong: Notebooks are for interactive development, not scheduling production pipelines.

Configure the endpoint to use manual scaling with a fixed number of replicas equal to peak traffic.

Why wrong: Manual scaling wastes cost when idle and cannot react to spikes automatically.

Enable automatic scaling with a maximum of 3 replicas to limit cost.

Why wrong: Limiting max replicas to 3 may cause throttling during spikes, increasing latency.

Set up model monitoring to detect prediction drift and retrain regularly.

Why wrong: Model monitoring is important for model quality but does not directly address latency or cost for spikes.