Practice Test #2

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.