CCNA Ml Data Model Management Questions

Option D is correct because in Vertex AI Pipelines, the `condition` block evaluates a boolean expression at pipeline compile time, not runtime. If the condition references an input variable rather than the actual output of the `evaluate` component, the pipeline will use the default or placeholder value (often `False`), causing the deploy step to be skipped even when the runtime metric is 0.9. The condition must directly reference the `evaluate` component's output (e.g., `evaluate.outputs['metric']`) to be evaluated correctly at runtime.

The `gcloud ai models list` command lists models within a specific region, as Vertex AI models are regional resources. If 'model-v3' was created in a different region, it would not appear in the output unless the `--region` flag is set to that region. This is the most likely reason the model is missing from the list.

The condition in the IAM policy uses the `resource.name.startsWith('dev-')` condition expression, which restricts access to Vertex AI model resources whose resource name begins with the prefix 'dev-'. This is a common pattern for environment-based access control, allowing the data scientist to only interact with models designated for development.

Option C is correct because Cloud Composer (based on Apache Airflow) recommends managing DAGs via source control and CI/CD pipelines to ensure version control, code review, and consistent deployment. This prevents conflicts when multiple data scientists contribute, as each change is tracked and tested before being synced to the DAGs folder in Cloud Storage, avoiding overwrites or broken workflows.

Option A is correct because storing training code in a Cloud Source Repository with tags linked to experiment IDs ensures that every team member can retrieve the exact code version used for a given experiment. This is a core reproducibility practice in Vertex AI Experiments, where the code snapshot is a key component of the experiment lineage.

Option C is correct because the error 'ResourceExhausted: Quota limits exceeded for read api requests' indicates that the BigQuery API is throttling requests from the client, even though the project-level quota is not exceeded. The preprocessing component likely uses a BigQuery client library that lacks exponential backoff retry logic, causing rapid, repeated requests that exhaust the per-client or per-connection quota. Implementing exponential backoff would allow the client to back off and retry, preventing quota exhaustion.

Option C is correct because enabling object versioning on a Cloud Storage bucket preserves each object's history, allowing the team to reference a specific version ID when reading data files. This ensures that every training run uses the exact same version of a file, eliminating inconsistency from concurrent uploads. The version ID acts as an immutable pointer, decoupling the training process from the bucket's live state.

Option B is correct because granting the product team's service account the roles/storage.objectViewer role at the bucket level provides read-only access to objects in that specific bucket, adhering to the principle of least privilege. This role allows the service account to list and read objects without granting broader permissions, such as modifying or deleting them, and scoping it to the bucket prevents unnecessary access to other buckets in the project.

Option B is correct because Google Cloud Resource Manager folders allow hierarchical IAM policy inheritance, enabling you to assign roles like 'roles/aiplatform.user' (for data science) and 'roles/aiplatform.admin' (for MLOps) at the folder level. This approach scales across multiple projects within the folder, ensuring consistent permissions without per-project duplication. It aligns with the principle of least privilege and centralized access management for Vertex AI resources.

Dataflow with Apache Beam is the correct choice because it provides a fully managed, serverless service for both batch and streaming data processing, which is ideal for transforming raw data from Cloud Storage into features for Vertex AI Feature Store on a daily schedule. Dataflow handles auto-scaling, exactly-once processing, and integrates natively with Google Cloud services, making it efficient for ETL pipelines that need to run reliably at scale.

Option D is correct because using a git repository (e.g., Cloud Source Repositories) provides version control, branching, and a full history of changes, which is essential for collaborative development. This approach avoids conflicts by allowing team members to work on separate branches and merge changes systematically, unlike shared storage or manual methods that lack conflict resolution and audit trails.

Option C is correct because Vertex AI Feature Store requires feature values to be stored in a low-latency online store (such as a Bigtable or Redis cluster) for serving. When features are stored in Cloud Storage, each online serving request must read from object storage, which introduces significant latency due to network overhead and lack of indexing. This design violates the fundamental architecture of Feature Store, which expects precomputed features in a key-value store optimized for sub-millisecond lookups.

Option D is correct because Vertex AI Model Registry version aliases (e.g., 'staging', 'production') are designed to track model version lifecycle stages. By integrating Cloud Build to trigger a Cloud Run service that enforces approval logic before updating the alias, you create a clear promotion gate. This approach natively supports tracking promotion requests and enforcing approval without custom databases or manual scripts, aligning with CI/CD best practices.

Option A is correct because Vertex AI Feature Store provides built-in feature monitoring that tracks data quality metrics (e.g., fraction of null values, distribution drift) and freshness (e.g., staleness of feature values). Enabling this monitoring is critical when multiple teams share a feature store to ensure that features remain reliable and up-to-date for downstream models, preventing silent degradation.

Locking dependency versions in a container image ensures that the exact same software environment (e.g., Python packages, CUDA libraries, system tools) is used every time a training job runs. This eliminates variability from package updates or OS patches, which is a fundamental requirement for reproducibility across teams. Vertex AI supports custom containers for training, making this a direct and reliable method.

Option A is correct because Vertex AI Model Registry supports cross-project sharing by allowing you to grant IAM roles with conditions on the model resource. This enables a model registered in one project to be accessed by a service account from another project without moving or copying the model artifacts.

Option E is correct because the `--parent-model` flag is required when uploading a new model version to an existing model in Vertex AI. Without specifying the parent model name, the command would attempt to create a brand-new model rather than adding a version to the existing 'my_model'. The `gcloud ai models upload` command uses this flag to associate the new version with the specified parent model.

Colab Enterprise notebooks with shared runtimes and IAM permissions is the recommended approach because it provides a fully managed, collaborative environment where multiple users can work on the same notebook simultaneously, with fine-grained access control via IAM and consistent runtime configurations. This eliminates version conflicts and environment drift, which are common in distributed notebook workflows.

Option B is correct because Vertex AI Pipelines provides a managed orchestration service for ML workflows, and a scheduled trigger can be set to run the pipeline when new labeled data arrives in BigQuery (e.g., via a Cloud Scheduler or Eventarc trigger). Cloud Build is used to pull approved libraries from Artifact Registry, ensuring only vetted dependencies are used during pipeline execution, which meets the security and compliance requirement.

Option E is correct because Vertex AI Model Registry supports cross-project access via IAM permissions, allowing the second project to directly deploy the model without copying artifacts. This approach maintains a single source of truth, avoids data duplication, and leverages Vertex AI's built-in versioning and lineage tracking. It is the recommended pattern for sharing models across projects in Google Cloud.

Cloud DLP (Data Loss Prevention) is a recommended method to de-identify sensitive data before sharing it with external partners. It can automatically detect and mask, tokenize, or redact PII, PCI, or other sensitive elements, ensuring that only anonymized data leaves your environment. This aligns with the principle of least privilege and data minimization for external collaboration.

Option B is correct because requiring code reviews for all changes to feature definitions before merging to the main branch enforces a peer-review gate, ensuring that modifications are validated for correctness, consistency, and compliance before they reach production. This aligns with MLOps best practices for governance and reduces the risk of introducing errors or breaking changes into the feature store.

Option E is correct because it combines Vertex AI Model Registry (which enforces that only validated models are promoted to production) with Cloud Build for automated deployment, and uses IAM conditions to restrict deployment permissions exclusively to the ML Engineering team. This ensures that models must pass the validation pipeline before deployment, and only authorized personnel can trigger the deployment process.

Vertex AI Experiments is the correct feature because it captures parameters, metrics, and artifacts for each pipeline run, enabling reproducibility and lineage tracking. This directly supports the team's need to ensure runs are reproducible and artifacts are tracked, as Experiments automatically logs metadata for every execution.

Vertex AI Model Registry is a managed service that automatically tracks model versions, artifacts, and lineage metadata (e.g., training runs, evaluation metrics, and source datasets). It provides a centralized hub for model governance, enabling reproducibility and auditability without manual versioning overhead. This makes it a best practice for versioning ML models in a production MLOps workflow.

Option C is correct because it enforces compliance at the image level: by building a custom container that installs only approved libraries from Artifact Registry at build time, and then restricting training job submission to that specific container using IAM, you ensure that no unauthorized libraries can be introduced at runtime. This approach eliminates the risk of developers injecting unapproved dependencies via startup scripts or runtime pulls, and it aligns with the principle of immutable infrastructure for ML training.

Option C is correct because it enforces governance at the source by using IAM conditions to restrict access to only approved datasets, preventing unauthorized data from being used in training. This approach integrates with the CI/CD pipeline to automatically pass only approved dataset references, eliminating the risk of human error in specifying Cloud Storage paths.

Option A is correct because Vertex AI Pipelines supports conditional execution via the `Condition` component or `if/else` operators within the pipeline DAG. This allows you to evaluate model metrics (e.g., accuracy, AUC) and, if they fall below a defined threshold, either skip the deployment step or explicitly fail the pipeline using `PipelineTask.fail()` or a conditional branch that raises an error. This is the native, declarative way to control pipeline flow based on evaluation results without relying on external services or manual intervention.

Option A is correct because using a CI/CD pipeline for deploying model versions ensures automated, repeatable, and auditable deployments, which is a best practice for collaboration and governance. This approach enforces version control, testing, and approval gates, reducing the risk of errors and enabling rollback if needed.

Option D is correct because enabling object versioning on a Cloud Storage bucket preserves all versions of an object, so even if a team member overwrites a dataset, the previous version remains accessible. This maintains collaboration (anyone can upload) while preventing permanent data loss. Lifecycle rules can then be used to manage storage costs by automatically deleting old versions after a specified period.

Option C is correct because Vertex AI Experiments with a prebuilt container ensures a fixed, reproducible environment by pinning the exact OS, Python version, and all dependencies. This eliminates the variability introduced by manual package installations and differing instance configurations, directly addressing the team's issue of inconsistent model metrics across runs.

Define the search space, then create and run the tuning job, monitor, and select the best parameters.

The 'deploy-model' step fails because the model was not successfully uploaded. Cloud Build's 'upload' step expects a valid SavedModel artifact (a directory containing a saved_model.pb file and variables subdirectory). If the artifact URI points to a directory that is not a valid SavedModel, the upload may appear to succeed but does not register a usable model resource, causing the subsequent deploy step to fail with 'model does not exist'.

Option C is correct because the root cause is a data version mismatch, not a code or environment issue. A data versioning tool like DVC (Data Version Control) tracks dataset versions via hash-based pointers in Git, ensuring the pipeline retrieves the exact dataset version used during training. This prevents silent failures when data processing steps change the data schema or content, which library pinning or manual reviews cannot guarantee.

The error 'Unable to submit build: The source code is not available' indicates that the Cloud Build environment cannot locate the source code when the 'gcloud builds submit' command is executed. This typically happens when the pipeline is triggered from Cloud Build but the source code is not properly staged or accessible in the build context, often because the build configuration does not include the source directory or the source is not uploaded to Cloud Storage. Option B correctly identifies that the command lacks access to the source code in the Cloud Build environment.

Vertex AI Model Registry is the recommended service for managing model versions across teams because it provides a centralized repository to track model versions, their associated metadata, and deployment history. It integrates natively with Vertex AI endpoints and pipelines, enabling consistent governance and lineage tracking across the ML lifecycle.

Pipeline components are key for MLOps in Google Cloud.

Option C is correct because it directly addresses the root cause of high latency in real-time inference: model size and compute requirements. Vertex AI Model Optimization applies quantization or pruning to reduce the model's memory footprint and computational cost, allowing it to run on a smaller, faster machine (e.g., fewer vCPUs or less GPU memory) while maintaining acceptable accuracy. This is the first step recommended by Google Cloud best practices for latency-sensitive deployments, as it reduces per-request processing time without requiring architectural changes.

Vertex AI Model Registry with versioning and alias (Option E) is the correct feature because it allows teams to manage model lifecycle, track approved versions, and assign aliases (e.g., 'champion' or 'production') to designate which model is approved for deployment. This ensures only vetted models are promoted to production, aligning with governance and compliance requirements.