Databricks-ML-Assoc Practice Test 2 — 25 Questions

Question 1

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 2

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 3

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 4

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 5

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 6

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 7

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 8

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 9

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 10

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 11

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 12

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 13

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 14

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 15

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

Question 16

You are using Databricks Feature Store to create a feature table that will be used for both batch training and online inference. The feature table must be refreshed daily with new data, and the online store must serve the latest feature values within minutes of the refresh. Which configuration should you use?

Accepted Answer

Create a feature table with online=True and use a Databricks Job to run a daily write that updates both the offline Delta table and the online store.. A feature table created with online=True is backed by both an offline Delta table and an online store. Writing to it via FeatureStoreClient.write_table publishes the new feature values to both stores. Running this write in a daily Databricks Job refreshes the online store with the latest data, enabling low-latency serving within minutes. Other options either omit the online store, use unsupported manual exports, or fail to meet freshness requirements.

Answer

Create a feature table with online=False, and configure Model Serving to read from the offline table at inference time.

Answer

Create a standard Delta table and manually export it to a key-value store each day using a notebook.

Answer

Create a feature table with online=True, but only write to it weekly to reduce costs.

Question 17

You are deploying a model using MLflow, and you want to log the custom pre-processing logic alongside the model so it is automatically applied during inference. How should you achieve this?

Accepted Answer

Use the mlflow.pyfunc.log_model() function with a custom code wrapper.. MLflow allows you to log custom Python functions or entire pipelines as part of the model using the 'pyfunc' flavor. By wrapping your pre-processing steps and model into a custom pyfunc class and logging it, you encapsulate both the transformation and the prediction logic. This is a critical best practice for production deployments, as it ensures consistent pre-processing between training and inference, eliminating training-serving skew and simplifying the deployment process for the serving endpoint.

Answer

Create a separate inference job that runs the pre-processing code before the model.

Answer

Store the pre-processing logic in a shared Delta table and call it at inference.

Answer

Log the pre-processing parameters as tags in the MLflow run and re-apply them.

Question 18

When using MLflow to track experiments, what happens if you invoke mlflow.end_run() inside a nested loop when the parent run is already active?

Accepted Answer

The active run is terminated, and subsequent logging calls outside the loop will fail if they assume the run is active.. Calling end_run() within a nested loop terminates the current active run. If it is part of a parent-child structure, ending the child prematurely could lead to incomplete data or orphaned metrics. Proper management requires careful scoping, often using context managers (with statements), to ensure that the run lifecycle is handled cleanly and that all sub-runs correctly report back to the primary experiment tracking context.

Answer

The entire experiment is deleted from the workspace.

Answer

The parent run automatically restarts to compensate for the closed child run.

Answer

The nested loop continues, but logging is redirected to the default root run.

Question 19

A machine learning engineer is using MLflow Tracking on Databricks to compare multiple runs. They want to programmatically retrieve the best run based on a metric called 'rmse' from an experiment. Which MLflow API call should they use?

Accepted Answer

`mlflow.search_runs()` with `order_by=['metrics.rmse ASC']`. `mlflow.search_runs()` is designed to query runs within an experiment and can order results by metrics. By specifying `order_by=['metrics.rmse ASC']`, the run with the lowest RMSE appears first. This is efficient and programmatic, unlike manually iterating runs or using functions that retrieve single runs or experiment metadata.

Answer

`mlflow.get_experiment_by_name()` and then filter runs by metric

Answer

`mlflow.get_run()` with the run ID of the best run

Answer

`mlflow.list_run_infos()` and manually iterate to find the minimum 'rmse'

Question 20

A data scientist is using Hyperopt with SparkTrials on a Databricks cluster to tune a scikit-learn model. They set max_evals=100 and parallelism=4. After the tuning completes, they notice that some trials failed due to memory errors on the workers. What is the most likely cause of these failures?

Accepted Answer

Each trial is training on the full dataset, and the dataset is too large to fit in the memory of a single worker.. The correct answer is that each trial is training on the full dataset, and the dataset is too large to fit in the memory of a single worker. SparkTrials distributes trials, but each trial runs on one worker with the full dataset. If the data is large, it can cause out-of-memory errors. To mitigate, you can reduce the dataset size, increase worker memory, or use distributed algorithms. The other options misattribute the cause to model incompatibility, driver memory, or autoscaling.

Answer

The scikit-learn model is being trained on the driver, causing memory pressure on the driver instead of workers.

Answer

SparkTrials does not support scikit-learn models and should be used only with MLlib.

Answer

The cluster's autoscaling is reducing the number of workers, causing trials to be queued and eventually fail.