Databricks-ML-Pro Model Development Practice Test 11 — 15 Questions

Question 1

A data scientist has trained a model and wants to register it in the MLflow Model Registry on Databricks. They want to indicate that the model is ready for testing in a pre-production environment. Which stage should they transition the model version to?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Staging. The MLflow Model Registry provides stages to manage model lifecycle. Staging is specifically meant for models that are undergoing testing or validation before production. By transitioning to Staging, the data scientist signals that the model is ready for pre-production evaluation, allowing stakeholders to test it without affecting live traffic.

Answer

Archived

Answer

None

Answer

Production

Question 2

A machine learning engineer is preparing a scikit-learn model for batch scoring with MLflow on Databricks. The team wants the logged model to carry a reproducible environment and a machine-readable description of the input and output schema so downstream consumers can validate requests. Which TWO actions should the engineer take when logging the model with `mlflow.sklearn.log_model`? (Choose two.)

Accepted Answer

Set `pip_requirements` to a pinned requirements file or list of exact package versions.. Reproducibility and schema validation are two distinct metadata concerns addressed by separate parameters. Pinning dependencies through `pip_requirements` records the exact package environment so the model can be restored consistently later. Building a `signature` with `infer_signature` records column names, types, and the output schema so scoring endpoints and the Registry can enforce input contracts. Together they make the logged model self-describing and portable across clusters.

Answer

Set `registered_model_name` to publish the model immediately to the Registry.

Answer

Pass `artifacts` pointing to the training notebook for reference.

Answer

Set `serialization_format` to `cloudpickle` to embed the environment.

Question 3

A machine learning engineer is training a model using MLflow on Databricks and wants to compare multiple runs to select the best hyperparameters. They need to view metrics across runs in a single interface. Which MLflow feature should they use?

Accepted Answer

MLflow Tracking UI. The MLflow Tracking UI is designed to display and compare runs, including metrics, parameters, and artifacts. It allows sorting and filtering, which is essential for selecting the best hyperparameters. Other MLflow components like Model Registry, Projects, and Recipes serve different purposes and do not provide a comparative run view. Thus, the Tracking UI is the correct tool.

Answer

MLflow Projects

Answer

MLflow Model Registry

Answer

MLflow Recipes

Question 4

A data scientist is using Databricks Feature Store to build a training set for a fraud detection model. The feature table contains a column `transaction_time` that is a timestamp. After creating the training set with `create_training_set`, the resulting DataFrame includes `transaction_time` but the model training code fails because the timestamp is not accepted by the XGBoost trainer. What is the most likely cause and correct resolution?

Accepted Answer

The training set includes the timestamp column because `create_training_set` does not automatically exclude non-numeric columns; the data scientist should drop or transform the timestamp column before passing the DataFrame to the XGBoost trainer.. `create_training_set` preserves the original data types of feature columns, so a timestamp column remains a timestamp. XGBoost cannot handle timestamp types directly, causing the training failure. The data scientist must either drop the column or transform it into numeric features such as hour, day of week, or time since a reference point. This ensures compatibility while retaining useful temporal signals.

Answer

The timestamp column should be excluded from the feature table and instead passed as a separate DataFrame column outside the Feature Store lookup.

Answer

The error occurs because the Feature Store requires all features to be of type double; the data scientist must cast the timestamp to double using `.cast('double')` before creating the training set.

Answer

Databricks Feature Store automatically converts timestamp columns to Unix epoch integers when creating the training set, so the trainer should accept them without modification.

Question 5

A machine learning engineer is using MLflow to track experiments and wants to compare multiple runs to identify the best model. They have logged metrics such as accuracy, precision, and recall. Which MLflow feature allows them to programmatically retrieve and compare these metrics across runs for further analysis?

Accepted Answer

mlflow.search_runs(). mlflow.search_runs() is designed to query and retrieve run data across experiments. It returns a pandas DataFrame with metrics, parameters, and tags, enabling programmatic comparison and analysis. This is ideal for identifying the best model by sorting and filtering based on metrics like accuracy or precision.

Answer

mlflow.log_metric()

Answer

mlflow.list_experiments()

Answer

mlflow.get_run()

Question 6

A team is developing a model on Databricks and wants to run an automated hyperparameter search over a scikit-learn pipeline. They need to try many parameter combinations in parallel across cluster workers while keeping every trial's parameters and metrics in MLflow. Which Databricks capability should they use to orchestrate the search?

Accepted Answer

Hyperopt with the `SparkTrials` backend passed to `fmin`.. The distributed hyperparameter search capability on Databricks is delivered by the Hyperopt integration with the `SparkTrials` backend. Passing `SparkTrials` to `fmin` turns each evaluation into a Spark task that runs on executors, allowing many configurations to be explored at once. Because the integration reports each trial to MLflow, the team gets parallel throughput and a complete, queryable record of every parameter set and its resulting metric.

Answer

A single-node grid search loop using `sklearn.model_selection.GridSearchCV` with `n_jobs=-1`.

Answer

Delta Live Tables pipelines with a `foreach` flow for each parameter set.

Answer

MLflow Projects with a `Multirun` entry point targeting the driver.

Question 7

A data scientist is using MLflow to log a model that includes a custom preprocessing step implemented in Python. They want to ensure that the preprocessing logic is packaged with the model so that it can be served consistently. Which MLflow model flavor should they use?

Accepted Answer

`mlflow.pyfunc`. The `mlflow.pyfunc` flavor is designed for custom Python models and allows embedding arbitrary preprocessing and postprocessing logic. By creating a `PythonModel` subclass, the data scientist can package the entire inference pipeline, ensuring consistency between training and serving. Other flavors are library-specific and may not capture custom Python steps outside their frameworks. Thus, `mlflow.pyfunc` is the correct choice.

Answer

`mlflow.tensorflow`

Answer

`mlflow.pytorch`

Answer

`mlflow.sklearn`

Question 8

A machine learning engineer is using MLflow to track experiments on Databricks. They notice that when they run `mlflow.log_artifact` with a local file path inside a notebook, the artifact is stored in the run's artifact location, but when they run the same code in a job cluster, the artifact is missing. The job cluster uses the same MLflow tracking server and experiment. What is the most likely reason for the missing artifact?

Accepted Answer

The local file path used in the job cluster points to a location that is not accessible from the driver, such as a path on the local filesystem of a different node, so the file does not exist when `log_artifact` is called.. In a Databricks job cluster, code may execute on the driver, but local filesystem paths are not shared across nodes. If the artifact file is created on an executor or a different node, the driver cannot access it when `log_artifact` is called. To ensure artifacts are logged, write them to a distributed storage location such as DBFS or a Unity Catalog volume, then log from there.

Answer

The MLflow tracking server rejects artifacts from job clusters because they lack an interactive user session, so the artifact is discarded.

Answer

The artifact location is configured with a short-lived credential that expires before the job cluster completes, causing the artifact upload to fail silently.

Answer

The job cluster does not have the MLflow library installed, so `log_artifact` silently fails without logging an error.

Question 9

A data scientist wants to record the exact library dependencies and a code snapshot alongside a model so that a reviewer can later restore the same environment and reproduce the training run. They are logging with MLflow on Databricks. Which practice best satisfies this requirement?

Accepted Answer

Log the model with `mlflow.sklearn.log_model` and pass pinned `pip_requirements` plus attach the source notebook as an artifact.. Reproducibility requires capturing two things: the environment and the code. Pinning `pip_requirements` when logging the model embeds a version-exact dependency manifest that MLflow restoration consumes. Attaching the source notebook records the training logic as it existed at that moment. Storing artifacts elsewhere or relying on autolog alone leaves one of these gaps, so the run cannot be faithfully recreated later.

Answer

Call `mlflow.log_artifact` on a generated `requirements.txt` and let autolog capture parameters only.

Answer

Log the model with `mlflow.sklearn.log_model` and rely on the cluster's installed libraries at load time.

Answer

Use `mlflow.autolog()` and set the experiment's artifact location to a Unity Catalog volume.

Question 10

A data scientist is training a model on Databricks and wants to track experiments using MLflow. They need to record the model's hyperparameters, evaluation metrics, and the resulting model artifact. They also want to be able to compare runs and reproduce results later. Which MLflow component should they use to organize these runs?

Accepted Answer

MLflow Experiment. MLflow Experiments are the fundamental unit for organizing runs. Each experiment can contain multiple runs, each capturing parameters, metrics, artifacts, and metadata. This structure enables easy comparison and reproducibility. While other MLflow components like the Model Registry and Projects play important roles, the experiment is the correct choice for grouping and tracking training runs during model development.

Answer

MLflow Tracking Server

Answer

MLflow Projects

Answer

MLflow Model Registry

Question 11

A data scientist wants to use MLflow to track a scikit-learn model training run on Databricks. They call `mlflow.sklearn.autolog()` before training. Which of the following will MLflow automatically log for this run?

Accepted Answer

The model signature, input examples, and the trained model artifact.. `mlflow.sklearn.autolog()` automatically logs parameters, metrics, the model signature, input examples, and the trained model artifact. It does not log source code, Git commit hash, hyperparameter search spaces, or custom plots like feature importance. This automation streamlines experiment tracking and ensures that key model metadata is captured without manual intervention.

Answer

The source code of the training script and the Git commit hash.

Answer

The hyperparameter tuning search space and the best parameters from a grid search.

Answer

The feature importance plot and confusion matrix for classification models.

Question 12

An ML engineer is training a model with a custom Python loop and wants MLflow to capture training metrics at regular intervals so that partial progress is visible before the run finishes. They are using `mlflow.start_run` and manual logging. Which approach correctly makes intermediate metrics visible during the run?

Accepted Answer

Call `mlflow.log_metric` inside the loop with the `step` argument set to the iteration number.. Intermediate visibility comes from persisting each metric as it is produced. Calling `log_metric` inside the loop writes the value immediately and the `step` argument positions it on the metric's time axis, producing a curve that updates live. Deferring logging to a single call at the end, or misusing tags, leaves no partial record if the run is interrupted.

Answer

Enable `mlflow.autolog()` and remove the manual logging calls from the loop.

Answer

Accumulate metrics in a Python list and call `mlflow.log_metrics` once after the loop completes.

Answer

Set the run tag `mlflow.note.content` inside the loop to the current metric value.

Question 13

A data scientist is using MLflow to log a model trained with scikit-learn. They want to ensure that the model can be loaded later for batch inference using `mlflow.pyfunc.load_model`. Which condition must be met for the model to be loadable as a PyFunc model?

Accepted Answer

The model must be logged with `mlflow.sklearn.log_model`, which automatically adds the `python_function` flavor.. To load a scikit-learn model as a PyFunc model, it must be logged with `mlflow.sklearn.log_model`, which automatically includes the `python_function` flavor. This flavor provides a consistent inference API across different model types. Registration is not required, nor is a signature or ONNX format. The key is that the logged model contains the PyFunc flavor, which `mlflow.pyfunc.load_model` uses to load and serve the model.

Answer

The model must be saved in the ONNX format to be compatible with PyFunc.

Answer

The model must be logged with a signature that defines the input schema; otherwise, PyFunc loading will fail.

Answer

The model must be registered in the MLflow Model Registry before it can be loaded as a PyFunc model.

Question 14

A machine learning team is using Databricks Feature Store to manage features for their models. They want to ensure that the features used during training are consistent with those served in production. Which TWO practices should they follow? (Choose two.)

Accepted Answer

Log the model with `FeatureStoreClient.log_model`, providing the feature lookups used during training.. To ensure consistency between training and serving with Databricks Feature Store, teams should use `create_training_set` to build training data from feature lookups and log models with `log_model` including those lookups. These practices embed the feature retrieval logic into the model, enabling automatic and consistent feature serving. Manual copying or disabling online publishing would introduce inconsistencies and are not recommended.

Answer

Use `FeatureStoreClient.score_batch` to score data in batch mode, which automatically handles feature retrieval.

Answer

Manually copy feature values from the offline store to the online store before each scoring request.

Answer

Disable online store publishing to avoid data duplication and reduce costs.

Question 15

A machine learning team is using Databricks to develop a model and wants to ensure that the model's input schema is validated at inference time to prevent errors from malformed data. Which TWO approaches allow them to enforce schema validation when serving the model with MLflow Model Serving? (Choose two.)

Accepted Answer

Log the model with an MLflow signature that specifies the expected input schema, and rely on MLflow Model Serving to reject requests that do not conform to the signature.. Logging a model with an MLflow signature enables Model Serving to automatically validate incoming requests against the expected schema, rejecting mismatches. Alternatively, a custom `pyfunc` model can implement explicit validation logic in its `predict` method. Both approaches enforce schema validation at inference time. The other options do not provide runtime validation for served models.

Answer

Enable MLflow Model Registry webhooks to validate the model signature before each inference request.

Answer

Use Databricks Feature Store to define the feature schema and rely on it to validate incoming requests at serving time.

Answer

Configure Model Serving to use a Delta table as the input source and enable schema evolution, so that any schema changes are automatically handled.