Practice Test #2

Not ideal because it calculates descriptive statistics and runs statistical analyses inside a notebook after importing data. With 850 million rows, pulling large volumes into a user-managed notebook is expensive and slow, and may exceed memory/IO limits. Looker Studio is fine for visualization, but the heavy computations should be pushed down to BigQuery to minimize compute and leverage MPP execution.

Incorrect because it relies entirely on a Vertex AI Workbench user-managed notebook for importing and analyzing the full dataset. Notebooks are not designed as a primary engine for scanning and aggregating hundreds of millions of records; this typically requires large VM sizing, long runtimes, and high cost. It also reduces reproducibility and scalability compared to BigQuery-based processing.

Partially correct: BigQuery is the right place for descriptive statistics at scale, and Workbench can run complex hypothesis tests. However, using notebooks to generate all time plots is not the most resource-efficient approach for interactive hourly/daily visual exploration. Looker Studio can query BigQuery directly and offload visualization without keeping notebook compute running.

"You Might Also Like" is commonly used for discovery and can improve click-through rate on a home feed, but CTR is not the same as revenue. Home feed users may be in browsing mode, so incremental clicks may not translate into larger baskets or higher AOV. For an explicit AOV +6% goal in a short timeframe, cross-sell at high-intent moments is typically more effective than broad personalization on the home screen.

This reverses best practice. Recommendations AI Retail requires a product catalog to exist so events can be correctly attributed to items and enriched with metadata. Importing events first can lead to unmatched item IDs, reduced training quality, and delayed time-to-value. The system does not "backfill" missing metadata reliably from events; you should upload/maintain the catalog first (or in parallel) and then stream/import user events.

Creating placeholder SKUs with default categories/prices is explicitly counterproductive for recommendation quality and business outcomes. Recommendations AI relies on accurate item attributes (category, price, availability) to train and to filter/serve relevant results. Placeholders can cause irrelevant or misleading recommendations (e.g., wrong price or out-of-stock), harming user trust and conversion. It also complicates governance and measurement during A/B tests, producing noisy results.

Mixing Vertex AI Pipelines for artifacts and MLflow for lineage adds unnecessary operational complexity and weakens standardization. MLflow tracking is not the native lineage store for Vertex Pipelines, so you would need custom integration to correlate pipeline steps, artifacts, and environments. This violates the “minimal custom code” and “simple to adopt via reusable templates” requirements and increases maintenance burden over time.

Vertex AI Experiments is primarily for experiment/run tracking (parameters, metrics, comparisons) and is not designed to provide full end-to-end lineage across multi-step pipelines and artifact dependencies. While ML Metadata can store lineage, using Experiments for artifacts is a mismatch: artifacts like datasets, checkpoints, and binaries are typically managed via pipeline artifacts and storage, with MLMD capturing their relationships automatically.

Using Cloud Composer to schedule lineage capture via Cloud Run functions is a custom-built metadata system. It requires significant bespoke code to infer lineage, map artifacts to steps, and maintain consistency across dev/stage/prod. This approach is harder to standardize, less reliable for audit-grade provenance, and does not leverage Vertex AI’s native MLMD integration, making it a poor fit for low-code, scalable governance.

Separating features in Feature Store and retraining without demographics is a remediation attempt, not the requested analysis. It also risks “fairness through unawareness,” which often fails because proxy variables (e.g., ZIP code, school, essay topics) can still encode demographics. Additionally, removing sensitive features can make it harder to measure fairness and audit outcomes by protected class. The board asked for transparent insight and cohort fairness evaluation first.

Vertex AI Model Monitoring focuses on operational issues like training-serving skew, feature drift, and prediction drift. While valuable for production reliability, it does not provide decision transparency for specific cases nor does it directly identify fairness issues across demographic cohorts. Retraining with recent data may even perpetuate or amplify bias if the underlying labeling or historical decision process is biased. This option addresses a different problem than requested.

Vector Search nearest-neighbor retrieval can help find similar examples, but it is not a primary tool for explainability or fairness auditing. Similarity search depends on embeddings and distance metrics and may not reveal which features drove the model’s decision or quantify demographic impacts. It can be a supplemental qualitative investigation technique, but it does not provide the systematic, per-feature, cohort-based transparency and bias evidence the board requested.

Assigning integer indices and feeding them as continuous numeric inputs is generally incorrect for neural networks because it introduces artificial ordinality and distance (e.g., category 10 appears “closer” to 11 than to 1000). This can mislead the model unless you use an embedding lookup (which the option does not mention). While memory-efficient, it violates the requirement to avoid ordinality.

Explicit one-hot encoding with a dimension per unique category is the most direct way to avoid ordinality, but it does not scale here. With hundreds of thousands of categories across multiple columns, the resulting vectors are extremely wide and can exceed GPU memory and increase compute costs. It also requires building and maintaining vocabularies, which is operationally heavy with evolving categories.

Run-length encoding is a compression technique for sequences/strings, not a standard ML encoding for categorical variables. It does not produce a stable numeric feature representation suitable for neural network ingestion, does not address ordinality, and does not provide a sparse categorical indicator structure. It would add complexity without solving the core modeling and scalability requirements.

BigQuery ML can train boosted tree models on tabular data, but manually inspecting tree split rules is not the same as obtaining per-instance feature attribution values for each online prediction. The question specifically asks for feature contributions for individual predictions, which requires an explanation mechanism rather than human inspection of model structure. This option also does not describe deploying a model to a Vertex AI endpoint with the explain method, which is the managed pattern that directly satisfies the requirement.

Logistic regression coefficients describe the overall relationship between features and the target across the model, so they are a form of global interpretability rather than per-instance explanation. A large coefficient does not directly tell you how much that feature contributed to one specific prediction, especially when feature values differ by example and preprocessing may affect interpretation. This option also does not provide a deployed online endpoint with per-request explanations in us-central1.

L1 regularization is applied during training to encourage sparsity and reduce the influence of less useful features, but it is not something enabled at prediction time to explain a result. Even if a model is trained with L1 regularization, that does not produce per-instance feature attribution values for each online prediction. The option uses Vertex AI deployment language, but it does not include Explainable AI or the explain method, so it does not meet the stated interpretability requirement.

Manual execution breaks automation and reproducibility, and it does not integrate cleanly with Vertex AI Pipelines orchestration. It introduces operational risk (missed runs, inconsistent parameters) and does not meet the requirement for a workflow task inside the pipeline. Exams generally penalize manual steps when an automated pipeline solution is requested.

A custom Python container calling the BigQuery API can work, but it is not the simplest approach. You must author code, manage dependencies (google-cloud-bigquery), build and store a container image, handle auth (Workload Identity/service account), and define artifact outputs. This is higher effort and maintenance than using a prebuilt component.

Creating a new component from scratch is even more work than option B. You would need to define component specs (inputs/outputs), containerization, versioning, and testing, duplicating functionality already available in official components. This contradicts the requirement for minimal custom code and lowest effort.

Incorrect. While it correctly separates training workers from the reduction service by using a third pool and the reductionserver image, it unnecessarily provisions GPUs for the reduction server pool. The reduction server primarily needs CPU, memory, and fast networking for tensor aggregation/transfer. Adding A100s increases cost significantly with little to no benefit, violating cost-optimization best practices.

Incorrect. The scenario explicitly uses PyTorch DDP on A100 GPUs. Switching to TPUs changes the hardware and typically the distributed training stack (e.g., XLA, different parallelism patterns). The reduction server strategy described is intended for GPU-based multi-node training; using TPUs here is not aligned with the stated setup and would require re-architecting the training job.

Incorrect. This doubles down on the TPU mismatch and also incorrectly assigns TPUs to the reduction server pool. The reduction server is not a compute accelerator workload; it is a communication/aggregation service. Provisioning TPUs (or GPUs) for it is wasteful and does not address the real bottleneck, which is network and CPU handling of gradient reduction across nodes.

This option can train and score data at the required scale, but it does not provide the strongest built-in end-to-end lineage. Moving the data into BigQuery is not necessary for the stated requirement, and custom prediction routines invoked through the SDK are not the same as an orchestrated pipeline that links training and prediction metadata together. You would need additional custom logic to correlate the exact training input snapshot, model version, and prediction output locations for audits. That makes it weaker than a single Vertex AI Pipeline containing both steps.

Vertex AI Experiments is useful for tracking runs and metrics, and Model Registry is useful for managing model versions, but neither service alone provides full workflow orchestration. This option also leaves the training process itself underspecified, so the lineage from the exact data snapshot and training execution to the registered model is incomplete. Although Vertex AI batch prediction can generate outputs at scale, the end-to-end chain from data to model to predictions is not as strongly captured as when both steps are executed inside a pipeline. Therefore, it does not best satisfy the requirement for built-in lineage across the entire monthly process.

A training pipeline is a good start because it can capture lineage for the training portion of the workflow. However, the option explicitly says batch predictions are generated directly in Vertex AI outside the pipeline, which breaks the single orchestrated lineage chain. That means the prediction outputs are not inherently tied to the same pipeline execution context as the training artifacts and model production step. For compliance and auditability, keeping prediction inside the pipeline is the stronger and more complete design.