Practice Test #1

Incorrect. Feature selection may reduce sensitivity to some drifting inputs, but it does not fix the root cause: the meaning/units/sampling of inputs changed. Removing “low-importance” features also won’t address that 27% of temperature values are out of range or that multiple key features have shifted. You still need monitoring and likely preprocessing updates and retraining on correctly interpreted data.

Incorrect. Hyperparameter tuning (e.g., L2 regularization) addresses overfitting/underfitting, not a production data contract change. With unit changes and distribution shift, tuning regularization may slightly stabilize predictions but will not restore accuracy reliably. The correct approach is to detect drift, validate feature semantics, update transformations, and retrain with representative recent data.

Incorrect. A fixed monthly retraining schedule is weaker than event-driven monitoring and response. It can leave the system degraded for weeks after a sudden upstream change. Feature selection still doesn’t solve unit/sampling changes. Best practice is continuous monitoring with alerting and automated pipelines that retrain when drift/performance thresholds are exceeded, with evaluation gates before deployment.

Skipping or commenting out components can reduce runtime, but it is a manual, error-prone workflow that changes the pipeline graph and may bypass important validations. It also doesn’t leverage Vertex AI Pipelines’ built-in orchestration best practices. In team settings, this harms reproducibility and makes it harder to compare runs because different runs execute different subsets of steps.

Dataflow can be excellent for large-scale ETL, but migrating feature processing to Dataflow is a redesign that adds operational overhead and may increase costs (Dataflow job charges, potential always-on resources, and additional integration). It also doesn’t inherently solve iteration speed if the pipeline still retriggers expensive processing; caching would still be needed.

Adding a T4 GPU increases cost and often provides little to no benefit for scikit-learn training, which is typically CPU-bound and not GPU-accelerated. Even if training sped up, the overall 80-minute runtime likely includes significant data ingestion/cleaning time, so a GPU would not address the main bottleneck and violates the “without increasing costs” requirement.

Natural Language API provides pretrained NLP capabilities (sentiment, entity extraction, and a limited content classification taxonomy). It is fast to integrate but offers minimal control over model architecture, training, and deployment. It also may not support custom 8-category warranty triage labels. This conflicts with the requirement to use TensorFlow and maintain full control over code, serving, and deployment, making it unsuitable here.

AutoML Natural Language can train a custom text classifier quickly from labeled data and is often a strong choice for rapid delivery. However, it is a managed training and serving solution where you do not maintain full control over the TensorFlow model code and deployment mechanics. While it can be orchestrated in pipelines, it violates the explicit requirement for full TensorFlow control, so it is not the best answer.

Using an established text classification model “as-is” is unlikely to work because the target labels are specific (8 warranty triage categories) and won’t match the pretrained model’s original label set or taxonomy. Even if the model outputs generic categories, it won’t map cleanly to your business classes without adaptation. The requirement emphasizes leveraging existing resources, but still implies customization; transfer learning is needed.

Dataproc/Spark can preprocess large datasets, but exporting transformed Parquet to Cloud Storage introduces extra data movement, storage management, and pipeline operations. It also risks training/serving skew because weekly inference is required to run directly in BigQuery; you would need to re-implement the same feature logic in BigQuery or continuously export new partitions. This is typically less cost-effective and less consistent than doing feature engineering in BigQuery.

Loading 2.6 TB (900M rows) into a local pandas DataFrame is infeasible due to memory and compute constraints and would be extremely slow and costly. It also breaks scalability and operational best practices for production ML. This option ignores distributed processing and BigQuery’s strengths, and it would not support ongoing weekly inference in BigQuery without duplicating preprocessing logic elsewhere.

Dataflow/Beam is strong for streaming and ETL, but writing preprocessed data as CSV is inefficient (large size, slow parsing, poor typing) and increases storage and pipeline overhead. Like option A, it also complicates training/serving consistency because inference must run in BigQuery; you would still need equivalent SQL feature logic or repeated exports for new partitions, increasing cost and operational complexity.

This is not an appropriate pattern because Cloud Functions do not typically deploy a new Cloud Composer DAG in response to storage events; DAGs are normally pre-authored and scheduled within an existing Composer environment. More importantly, Cloud Composer is a long-lived Airflow environment with ongoing baseline cost, which conflicts with the requirement to minimize always-on orchestration compute. A per-file trigger would also react to each object arrival rather than naturally reasoning about all files since the last successful run. For an ML workflow on Google Cloud, Vertex AI Pipelines is the more suitable orchestrator.

A Cloud Storage-triggered Cloud Function would fire on every object creation event, so with 40–60 files per hour and bursty arrivals, this could launch many separate pipeline runs. That does not inherently satisfy the requirement to run only when new files have arrived since the last successful run as a single coordinated batch unless additional debouncing, locking, and aggregation logic is built. The option does not mention such coordination, so it is incomplete and operationally risky. It may also create duplicate or overlapping runs during bursts.

Cloud Composer can orchestrate the workflow, but it requires an always-on Airflow environment with persistent scheduler and worker resources. That directly conflicts with the requirement to minimize always-on compute costs for orchestration. Using a GCSObjectUpdateSensor also implies a heavier polling/sensor-based pattern than necessary for this use case. While technically feasible, it is less cost-effective and less aligned with Google Cloud's managed ML orchestration approach than Vertex AI Pipelines plus a lightweight trigger.