Databricks-ML-Assoc Practice Exam 2 — 20 Questions

Question 1

When a data scientist needs to share an MLflow experiment with a team member, what is the best practice for ensuring collaborative access within Databricks?

Accepted Answer

Granting appropriate permissions on the experiment within the MLflow UI.. Sharing experiments is done by managing permissions on the experiment object itself. In Databricks, you can grant specific permissions (e.g., CAN_VIEW, CAN_MANAGE) to individual users or groups. This allows for controlled collaboration where team members can see experiment results without necessarily having the ability to modify or delete them, adhering to the principle of least privilege while fostering efficient teamwork during the development process.

Answer

Exporting the experiment to a CSV file and emailing it.

Answer

Moving the experiment to a public folder in DBFS.

Answer

Giving everyone admin access to the workspace.

Question 2

An ML engineer wants to package a training project so it can be run reproducibly from a Databricks Job across environments, with its Python dependencies and entry point defined. Which MLflow capability should be used?

Accepted Answer

MLflow Projects, using an MLproject file to declare the entry point and environment.. MLflow Projects are the packaging mechanism for reproducible runs: the MLproject file specifies the entry point and the environment via a conda or pip specification, and executing the project records source and parameters in a run. Models capture artifacts, Tracking records results, and Recipes impose a specific template, so none of those define a reusable training entry point with dependencies for a Databricks Job.

Answer

MLflow Tracking, by logging parameters and metrics for each run.

Answer

MLflow Recipes, by defining a step-based pipeline with profiles.

Answer

MLflow Models, by saving the estimator with a signature.

Question 3

What is the primary technical limitation when deploying an MLflow model that has custom Python dependencies not included in the standard Databricks Runtime?

Accepted Answer

The serving container will fail due to missing runtime libraries.. When using custom libraries, the inference environment must be able to install and manage these dependencies. MLflow handles this by utilizing environment specifications (like Conda or pip requirements). If these dependencies are not explicitly defined or cannot be resolved at deployment time, the serving container will fail to start. This highlights the importance of properly managing the environment specification to ensure the target serving infrastructure has the necessary software components available.

Answer

The model will automatically install the missing libraries.

Answer

The model will be rejected by the registry.

Answer

The model cannot be used with MLflow.

Question 4

A data scientist is using Databricks AutoML to train a classification model on a dataset with a binary target. They want to understand which features contributed most to the model's predictions and need a human-readable summary. Which AutoML output should they examine?

Accepted Answer

The AutoML-generated notebook that includes a section on model interpretability with SHAP values.. AutoML generates a notebook for each trial that includes model interpretability using SHAP. This notebook contains summary plots and feature importance rankings that are human-readable and explain the model's predictions. Examining this notebook is the correct way to understand feature contributions.

Answer

The MLflow run's artifact directory, specifically the 'feature_importance.json' file.

Answer

The Databricks Feature Store UI, which shows feature lineage and importance scores.

Answer

The Model Registry's version description, which is automatically populated with feature importance by AutoML.

Question 5

A machine learning engineer needs to track hyperparameter tuning runs and log artifacts using MLflow inside a Databricks Notebook. Which approach should be used to ensure runs are automatically nested under a parent run?

Accepted Answer

Utilize mlflow.start_run(nested=True) inside the hyperparameter optimization loop while a parent run is active.. Using `mlflow.start_run()` with a `nested=True` parameter ensures that child runs are correctly organized beneath an active parent run within the MLflow tracking server. This hierarchical structuring is essential for organizing complex hyperparameter optimization sweeps, enabling data scientists to easily compare child performance metrics against the overarching parent experiment trial in the Databricks UI.

Answer

Call mlflow.start_run() inside a loop without any arguments while an active run exists.

Answer

Set the MLFLOW_PARENT_RUN_ID environment variable manually before invoking mlflow.start_run().

Answer

Configure the MLflow client to use a hierarchical tracking URI scheme before logging parameters.

Question 6

Which of the following is a primary benefit of using a model serving endpoint versus a batch inference job?

Accepted Answer

Real-time, low-latency inference. Model serving endpoints provide low-latency, real-time responses to individual requests via REST APIs. This is essential for applications like fraud detection or recommendation engines, where an immediate prediction is required for a user interaction. Batch inference jobs, conversely, are designed for high-throughput, asynchronous processing of large datasets at scheduled intervals. Understanding these use cases is vital for selecting the correct deployment architecture to meet performance and latency requirements.

Answer

Lower cost for infrequent predictions

Answer

Ability to process billions of rows at once

Answer

Simplified tracking of data lineage

Question 7

What is the primary role of the 'Model Signature' in a Databricks ML lifecycle?

Accepted Answer

To enforce input schema validation at serving time.. The Model Signature defines the schema of the inputs and outputs, serving as a formal contract. This contract is used by the serving infrastructure to validate incoming requests, ensuring that they match the expected format. It helps catch errors early in the deployment lifecycle, protecting production endpoints from malformed data. By providing this metadata, developers ensure that their model is compatible with the standard Databricks serving interfaces, enabling seamless integration into production applications.

Answer

To identify which user trained the model for audit logs.

Answer

To increase the prediction accuracy by normalizing inputs.

Answer

To compress the serialized model file size for faster loading.

Question 8

A data scientist registers a model in the Databricks Model Registry and wants to record the model's intended input and output schema so that a serving endpoint can validate incoming requests. Which action accomplishes this when logging the model?

Accepted Answer

Log the model with an inferred or explicit signature using MLflow. A model signature is part of the logged MLflow model artifact and is what the serving runtime uses to validate request payloads against expected input and output types. Registry stages, endpoint tags, and external documentation are metadata that the runtime does not interpret as a schema, so only logging the model with a signature achieves request validation.

Answer

Add the schema to the endpoint's tags in the serving configuration

Answer

Store the schema as a separate Delta table and reference it in the model's README

Answer

Set the model version's stage to Production in the Model Registry

Question 9

When using MLflow to manage the lifecycle of a model in Databricks, why should you use the Model Registry instead of just saving model files to DBFS?

Accepted Answer

It allows for versioning and stage management of models.. The Model Registry provides versioning, stage transitions (e.g., Staging to Production), and centralized access control, which are essential for governed model deployment. Directly saving to DBFS ignores these enterprise features, making it impossible to track lineage or manage model lifecycle status effectively. Using the Registry creates an audit trail and standardizes the deployment workflow, which is critical for compliance and ensuring that only validated models move into production environments.

Answer

It automatically compresses the model files to save storage space.

Answer

It allows models to be trained directly on the registry.

Answer

It converts models into a proprietary format for faster inference.

Question 10

Which approach is most efficient for handling high-cardinality categorical features in a machine learning model while maintaining compatibility with standard Databricks model serving?

Accepted Answer

Using the Feature Store to store pre-computed embeddings.. Using Feature Store to pre-compute and transform high-cardinality features allows you to store them as embeddings or encoded vectors. This shift moves the expensive computation from the inference phase to an offline batch process, significantly reducing latency. This approach is compatible with standard model serving, as the model only receives the pre-calculated features, ensuring consistent and performant real-time inference within the Databricks ecosystem.

Answer

One-hot encoding the features inside the model inference function.

Answer

Converting features to strings and letting the model handle them natively.

Answer

Running a Spark job on every prediction request to re-encode the features.

Question 11

A data scientist trains a scikit-learn model in a Databricks notebook and calls mlflow.sklearn.log_model with the registered_model_name argument set to 'churn_model'. Later, a colleague needs to know which source notebook and Git commit produced run ID 3f8a1c. Where can this information be retrieved?

Accepted Answer

In the MLflow Experiment page, open the run and inspect the run's tags, including mlflow.source.name and mlflow.source.git.commit.. MLflow automatically attaches metadata tags to each run, including the source notebook path, Git commit, and user. These tags are visible on the run detail page in the experiment UI, making it the authoritative place to trace a run back to its originating notebook and revision. Registry entries and artifact files like conda.yaml do not carry this provenance.

Answer

In the MLflow run's artifact directory, open the conda.yaml file, which records the source notebook path and Git commit used during training.

Answer

In the Databricks Model Registry, open version 1 of churn_model and read the 'Source' field, which stores the originating notebook path and Git commit.

Answer

In the Databricks Jobs UI, locate the task that ran the notebook and read its run history, which stores the MLflow run ID and its source metadata.

Question 12

A data scientist registers a scikit-learn model in the Unity Catalog model registry with the name `prod.ml_team.fraud_detector`. They now want to serve it with Databricks Model Serving. Which value should be supplied as the model identifier when creating the serving endpoint?

Accepted Answer

prod.ml_team.fraud_detector. Because the model was registered in Unity Catalog, the endpoint must be created from the three-level namespace catalog.schema.model_name, optionally pinned to a version. Stage-based URIs and raw storage or run paths do not identify a Unity Catalog registered model, so they cannot be used as the served entity. The fully qualified name is the correct identifier.

Answer

models:/prod.ml_team.fraud_detector/Production

Answer

dbfs:/databricks/mlflow/prod/ml_team/fraud_detector

Answer

runs:/<run_id>/model

Question 13

When performing hyperparameter tuning using Hyperopt on Databricks, which function is primarily used to distribute the training task across the cluster?

Accepted Answer

SparkTrials(). Hyperopt leverages the SparkTrials class to distribute tuning tasks. By using SparkTrials, Databricks orchestrates multiple training trials in parallel across the cluster nodes, significantly reducing the time required for grid or random search. This integration is vital for efficiently exploring complex hyperparameter spaces, allowing data scientists to iterate faster on model architectures without manual resource management or complex parallelization code.

Answer

fmin()

Answer

parallel_task()

Answer

distributed_fit()

Question 14

A data scientist registers a scikit-learn model in Unity Catalog as `prod.ml.churn_model`. They then create a Databricks Model Serving endpoint via the REST API using `served_entities` with `entity_name` set to `prod.ml.churn_model` and `entity_version` set to `"3"`. The endpoint creation fails. What is the most likely cause?

Accepted Answer

The serving endpoint lacks USE CATALOG, USE SCHEMA, and EXECUTE privileges on the Unity Catalog model, so the service principal cannot read the model artifacts.. Serving a Unity Catalog model requires the serving identity to hold USE CATALOG, USE SCHEMA, and EXECUTE privileges on the catalog, schema, and model. Without these grants, the endpoint cannot retrieve the model version, and creation fails. Referencing the model by three-level name and version string is otherwise correct, so permissions are the most likely root cause.

Answer

Model Serving only supports models registered in the workspace Model Registry, not models registered in Unity Catalog.

Answer

The model version must be referenced as a numeric integer, but the field only accepts a string, so the deployment cannot resolve the artifact path.

Answer

The model must first be exported to DBFS as an MLflow artifact tarball before it can be referenced by a serving endpoint.

Question 15

Why should you use an inference table in Databricks Model Serving?

Accepted Answer

To provide visibility into production inputs and predictions. Inference tables allow you to capture every request and response processed by a model endpoint. This is vital for monitoring model performance over time, debugging issues by examining specific input-output pairs, and detecting data drift. Without this captured data, you essentially have no visibility into how the model is performing in the real world, which makes it impossible to maintain and improve the system effectively.

Answer

To increase the speed of model inference

Answer

To automatically retrain the model on new data

Answer

To secure the endpoint against malicious attacks

Question 16

An ML engineer has registered a model in the Databricks Model Registry. The model must be deployed to a REST endpoint that automatically scales with traffic and provides a stable serving environment. Which Databricks capability should they use?

Accepted Answer

Databricks Model Serving with the registered model version as the served entity.. Databricks Model Serving provides a managed, serverless endpoint for registered model versions. It automatically scales with request volume and offers a stable serving environment, eliminating the need to run and maintain a web server. The other options either require manual server management or are intended for interactive or batch use, not production REST serving.

Answer

Export the model as an MLflow artifact and load it in a Databricks notebook using mlflow.pyfunc.load_model for interactive scoring.

Answer

MLflow Model Registry webhooks that trigger a deployment script when the model version transitions to Production.

Answer

A Databricks job that runs a Python web server on a cluster and exposes the model via a public URL.

Question 17

Which of the following is the recommended workflow for developing a scalable model on Databricks?

Accepted Answer

Perform EDA, feature engineering, distributed training, and register with MLflow.. The iterative cycle of data exploration, feature engineering, distributed training, and model registry management is the standard Databricks practice. By utilizing MLflow throughout, scientists ensure reproducibility. Scaling is handled by Spark, and the Feature Store ensures the same data definitions are used for both training and inference. This workflow bridges the gap between ad-hoc experimentation and production-ready machine learning, ensuring that the model is robust, documented, and easily deployable via standard enterprise pipelines.

Answer

Train a model on a local machine, then upload the final artifact to Databricks.

Answer

Use a single-node cluster for all stages to avoid network latency.

Answer

Skip logging metrics to save space and improve training speed.

Question 18

A machine learning engineer needs to track model experiments in Databricks and wants to ensure that model artifacts are versioned automatically. Which approach best leverages Databricks-native capabilities for this requirement?

Accepted Answer

Invoke mlflow.autolog() at the start of the training script to capture parameters, metrics, and model artifacts automatically.. MLflow tracking is the standard in Databricks for recording experiments. Using mlflow.autolog() automatically captures parameters, metrics, and artifacts during model training runs, ensuring consistency and reproducibility across team members. This is essential for managing the model lifecycle, as it eliminates manual logging errors and provides a clear lineage from source code to the registered model artifact within the Unity Catalog or Model Registry environment.

Answer

Manually save model weights to a DBFS mount point using a standard Python dictionary to track parameters.

Answer

Write a custom function to append training results to a Delta table and store serialized model objects as binary columns.

Answer

Use the standard Python logging module to output training metrics to a text file saved in the user home directory.

Question 19

A data scientist wants to package a training script so that it can be run repeatedly with different hyperparameters and shared with colleagues who use different Python library versions. The script must create a reproducible environment. Which MLflow component should they use to define the project and its dependencies?

Accepted Answer

MLflow Projects with an MLproject file and a conda.yaml environment specification.. MLflow Projects are designed to package code with a clear entry point and parameter definitions, and the conda.yaml file locks dependency versions for reproducibility. This lets colleagues run the same training script with different hyperparameters in an isolated environment. Tracking, Models, and the Model Registry serve different lifecycle stages and do not provide project packaging.

Answer

MLflow Tracking with a dedicated experiment and run tags for each library version.

Answer

MLflow Models with a custom Python function flavor and a requirements.txt file.

Answer

MLflow Model Registry with stage transitions and model version descriptions.

Question 20

What is the primary function of the 'Model Registry' in the Databricks ML ecosystem?

Accepted Answer

To provide a centralized platform for model lifecycle management. The Model Registry provides a centralized hub for managing the full lifecycle of a machine learning model. It allows teams to track versions, manage model stages (Staging, Production, Archived), and facilitate collaboration. By serving as a 'source of truth' for model status, it ensures that stakeholders can confidently transition models from development to production while maintaining complete audit trails and lineage of all changes applied to the model artifacts.

Answer

To store raw training datasets for feature engineering

Answer

To execute distributed hyperparameter tuning experiments

Answer

To monitor real-time inference drift in production