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

Question 1

Which TWO actions should a data scientist take when using Feature Store to ensure optimal performance and feature reusability across training and inference?

Accepted Answer

Define a primary key for each Feature Table to support point-in-time joins during model training.. Properly utilizing Feature Store involves both defining schemas for data integrity and ensuring the feature tables are accessible for real-time serving. These steps are critical because they decouple feature engineering from model training, allowing teams to share high-quality, pre-computed features across different models, thereby reducing latency and preventing training-serving skew in production machine learning workflows.

Answer

Store all features in a single, massive feature table to minimize join latency during training.

Answer

Use the update_feature_table function to modify the schema of existing feature tables without re-writing data.

Answer

Always set the training dataset split ratio to 90/10 to maximize feature coverage.

Question 2

Which THREE factors should be considered when selecting a model for deployment in the Model Registry to ensure reliable production performance?

Accepted Answer

The model version's performance metrics compared to established baselines.. Evaluating models for production requires a holistic view that covers technical performance, reliability, and security. By considering these factors, teams can prevent the deployment of models that might behave unexpectedly under load, have security vulnerabilities, or fail to meet the business requirements, thereby maintaining the stability and integrity of the production environment.

Answer

The total number of parameters in the model architecture.

Answer

The popularity of the framework used to train the model.

Question 3

A Databricks machine learning engineer is optimizing a pipeline using Hyperopt. They need to ensure efficient search space exploration. Which TWO capabilities are inherent to the Hyperopt integration with MLflow on Databricks?

Accepted Answer

Automatic logging of hyperparameter values and objective metrics.. Hyperopt integrated with MLflow on Databricks streamlines the tuning process by automatically logging search parameters and objective metrics for every trial. By utilizing the 'mlflow.spark.autolog' or explicit tracking, engineers avoid manual bookkeeping. This integration is crucial for maintaining audit trails of model development, allowing teams to replicate successful runs and analyze hyperparameter impact on model performance metrics consistently.

Answer

Automatic deployment of the best trial to the Model Registry.

Answer

Dynamic adjustment of the training dataset based on loss.

Answer

Native conversion of models to SQL for faster inference.

Question 4

A machine learning team is preparing to move a model into production using Databricks. They must ensure the model is robust and compliant. Which THREE actions are recommended for production-grade model development in Databricks?

Accepted Answer

Transition the model to the 'Production' stage in the Model Registry.. Production-grade model development necessitates moving beyond simple experimentation to robust lifecycle management. This involves rigorous versioning of models, ensuring reproducibility through environment capture, and implementing automated testing or validation. By leveraging the Model Registry, using Feature Store to ensure data consistency, and documenting dependencies, teams create a stable pipeline that survives the transition from notebook-based exploration to highly available production inference endpoints.

Answer

Store all training data as CSV files for compatibility.

Answer

Hardcode all database connection strings in the model code.

Question 5

A data scientist is using MLflow on Databricks to track a scikit-learn training run. After fitting the model, they call `mlflow.log_artifact('feature_importance.csv')` inside the active run. They later discover that the artifact is not associated with the run in the MLflow UI. What is the most likely cause?

Accepted Answer

The artifact was logged to a different run because no active run was set.. MLflow associates artifacts with the currently active run. If `log_artifact` is called without an active run context, the artifact may be attached to a different run or a new run, making it appear missing from the expected run in the UI. Wrapping the call inside `with mlflow.start_run():` ensures correct association.

Answer

Artifacts larger than 1 MB are not logged unless `mlflow.set_tracking_uri` is configured.

Answer

`log_artifact` must be called outside of a `with mlflow.start_run()` block.

Answer

The artifact path must be absolute; relative paths are silently ignored.

Question 6

A data scientist is training a scikit-learn model on Databricks and wants to use MLflow to track each training run. They also need to compare hyperparameter tuning results across multiple runs and later register the best model. Which MLflow API call should they use to start a new run and automatically log parameters, metrics, and the model artifact?

Accepted Answer

mlflow.sklearn.autolog(). Using mlflow.sklearn.autolog() enables automatic logging of parameters, metrics, and the model for scikit-learn training runs. This eliminates manual logging code and ensures consistent capture of tuning results. The other options either only start a run, set an experiment, or are invalid API calls. Automatic logging is the most efficient way to track and compare multiple hyperparameter tuning runs and later register the best model.

Answer

mlflow.log_model()

Answer

mlflow.set_experiment()

Answer

mlflow.start_run()

Question 7

You are tuning a scikit-learn gradient boosting classifier on Databricks using Hyperopt. The search space has 12 hyperparameters, and each trial takes about 4 minutes. You want to explore as many configurations as possible within a 2-hour budget while keeping the driver responsive. Which Hyperopt configuration should you use with `fmin()`?

Accepted Answer

`SparkTrials(parallelism=8)` with `max_evals=30`. Distributing Hyperopt trials with SparkTrials and a sensible parallelism value lets many configurations run concurrently on the cluster, so more evaluations fit in the time budget and the driver remains free. Sequential Trials or an unspecified trials class would run one trial at a time, and excessive parallelism causes contention rather than speedup.

Answer

`Trials()` with `max_evals=30`

Answer

`SparkTrials(parallelism=32)` with `max_evals=30`

Answer

`Hyperopt` with `algo=tpe.suggest` and no trials class

Question 8

A machine learning engineer is using MLflow to track experiments on Databricks. They need to ensure that the model training runs are fully reproducible, including the environment and code state. Which TWO practices should they implement? (Choose two.)

Accepted Answer

Specify the Python environment using a conda.yaml file and log it with the run.. To achieve full reproducibility, the engineer must log both the code state (via Git commit hash and repository URL) and the environment (via conda.yaml). These two practices ensure that the exact code and dependencies can be restored. Autologging does not capture these by default, and saving the entire project or external weights does not provide a clean, versioned reference.

Answer

Store the model weights in a separate cloud storage bucket and reference the path in the run.

Answer

Use `mlflow.log_artifact` to save the entire project directory as a zip file.

Answer

Enable MLflow autologging for all frameworks, which automatically records the Git commit hash and conda environment.

Question 9

A machine learning engineer is developing a scikit-learn model on Databricks and wants to log it to MLflow while ensuring the model can be scored directly from the registry without loading Python dependencies. Which MLflow model flavor or logging approach should be used?

Accepted Answer

Log the model using `mlflow.onnx.log_model` after converting the scikit-learn model to ONNX format.. Logging a scikit-learn model in ONNX format allows it to be scored by an ONNX runtime, which is available in multiple languages and does not require Python or scikit-learn. This satisfies the need to avoid Python dependencies during scoring. The other options either retain Python dependencies or are invalid logging methods for this purpose.

Answer

Log the model using `mlflow.pyfunc.log_model` with the `python_model` argument set to the scikit-learn model object directly.

Answer

Log the model using `mlflow.sklearn.log_model` and set the `signature` parameter.

Answer

Log the model using `mlflow.pyfunc.log_model` with a custom Python wrapper that imports scikit-learn at inference time.

Question 10

A data scientist is using MLflow to track experiments on Databricks. They want to ensure that their model training runs are reproducible. Which TWO actions should they take to guarantee reproducibility? (Choose two.)

Accepted Answer

Set a random seed for all libraries that use randomness.. To guarantee reproducibility, one must log all hyperparameters and set random seeds. Hyperparameters define the model's configuration, and random seeds control stochastic elements. Together, they ensure that given the same data and code, the training process yields identical results. Other actions like logging metrics or artifacts are useful but not sufficient for reproducibility.

Answer

Log the training dataset as an artifact.

Answer

Log the model's architecture using `mlflow.log_artifact`.

Answer

Use `mlflow.log_metric` to record evaluation metrics.

Question 11

A machine learning engineer is using MLflow on Databricks to track experiments for a computer vision model. They want to ensure that each run captures enough information to reproduce the training environment and results. Which TWO actions should they perform? (Choose two.)

Accepted Answer

Log the Git commit hash of the training code repository.. Reproducibility requires capturing the code version and the environment dependencies. The Git commit hash identifies the exact code, and library versions ensure the runtime environment can be recreated. Dataset references and cluster specs are helpful but not strictly required, and logging full datasets or predictions is not standard for reproducibility.

Answer

Log the entire training dataset as an artifact.

Answer

Log the cluster's node type and number of workers.

Answer

Log the model's final predictions on the test set.

Question 12

A data scientist is developing a model on Databricks and wants to ensure that the model's training code and environment are reproducible. They are using MLflow Tracking and have logged parameters, metrics, and the model artifact. However, when they attempt to reproduce the run on a different cluster, the model fails to load due to missing dependencies. Which MLflow feature should they leverage to capture the exact library versions used during training?

Accepted Answer

Rely on MLflow's automatic logging of the conda environment when logging the model with `mlflow.log_model()`.. MLflow automatically logs a conda environment (conda.yaml) when a model is logged via log_model. This file captures exact library versions and is used to recreate the environment during model loading, ensuring reproducibility. Manual logging of requirements or conda list is error-prone and not integrated with MLflow's model loading.

Answer

Use `mlflow.log_artifact()` to save the cluster's `conda list` output.

Answer

Set the `MLFLOW_TRACKING_URI` to point to a cluster with the same libraries.

Answer

Log the `requirements.txt` file manually as an artifact.

Question 13

A data scientist is using Databricks Feature Store to build a training set for a fraud detection model. The feature table contains a `transaction_time` column that is a timestamp, and the model requires a feature representing the hour of day. The data scientist wants to ensure that the same transformation is applied at inference time to avoid training-serving skew. Which approach should they take?

Accepted Answer

Register the feature table with a transformation function using `FeatureStoreClient.create_feature_table()` and specify the function in the `training_set` creation.. The correct approach is to register the feature table with a transformation function. Databricks Feature Store supports defining transformations at feature table creation, which are then applied consistently during training set generation and batch scoring. This encapsulates the logic and eliminates the need for separate pipelines or manual intervention, directly addressing training-serving skew.

Answer

Create a derived feature using a Delta Live Tables pipeline that computes the hour from `transaction_time` and registers it as a separate feature table.

Answer

Define the hour feature as a SQL expression in the feature table's metadata using `FeatureStoreClient.create_feature_table()` with a `partition_by` clause.

Answer

Use `FeatureStoreClient.create_training_set()` with a custom transformer that computes the hour from `transaction_time` and log the transformer with the model.

Question 14

A data scientist is using Hyperopt with MLflow on Databricks to tune a gradient boosting model. They want to ensure that the best hyperparameters are automatically logged and that the tuning process can be reproduced later. Which TWO actions should they take? (Choose two.)

Accepted Answer

Use `fmin` from Hyperopt with the `mlflow.log_params` call inside the objective function to log each trial's hyperparameters.. Using Hyperopt's `fmin` with explicit `mlflow.log_params` inside the objective function ensures each trial's hyperparameters are logged. Additionally, using `SparkTrials` automatically logs trial details to MLflow, providing a complete record of the tuning process. Together, these actions enable reproducibility and easy identification of the best hyperparameters.

Answer

Manually log the best hyperparameters after tuning using `mlflow.log_params` with the best parameters from `fmin`.

Answer

Set the `MLFLOW_TRACKING_URI` environment variable to the Databricks workspace URL before starting the tuning.

Answer

Call `mlflow.autolog()` before defining the objective function to capture all hyperparameters and metrics.

Question 15

A data scientist is using MLflow tracking on Databricks to log experiments for a computer vision model. They want to ensure that the model's input schema and output schema are captured for downstream validation. Which TWO actions should they take? (Choose two.)

Accepted Answer

Call mlflow.log_model() with the signature parameter set to an inferred signature using mlflow.models.infer_signature().. To capture input and output schemas, the model must be logged with a signature object. This can be done by inferring the signature from sample data and passing it to log_model(), or by explicitly providing a signature when logging a custom pyfunc model. Both approaches embed the schema in the MLmodel file, allowing MLflow to validate inputs and outputs during serving and batch inference. Other methods do not integrate the schema into the model's metadata.

Answer

Enable autologging with mlflow.autolog() before training, which automatically captures the signature for all model types.

Answer

Use mlflow.log_artifact() to save a JSON file containing the input and output schema alongside the model.

Answer

Define the signature in the model's conda.yaml environment file so it is captured during model loading.