Databricks Certified Machine Learning Associate

Question 1

A data scientist has a scikit-learn model that expects a pandas DataFrame and returns a prediction plus a probability score. They want to distribute batch inference across a large Spark DataFrame by grouping records by 'region' and applying the model to each group's data as a pandas DataFrame using groupBy().applyInPandas(). What must be provided for this to execute correctly on Spark?

Accepted Answer

An explicit output schema (StructType) describing the columns and types the applied function returns

Answer

A registered Unity Catalog model URI passed directly to applyInPandas()

Answer

A returnType argument specifying only a single scalar type such as DoubleType

Answer

A vectorized pandas_udf decorator applied to the grouping function

Question 2

A data scientist runs an AutoML classification experiment through the Databricks AutoML UI to predict customer churn. After the experiment completes, they want to understand and customize the feature engineering and hyperparameters used by the top-performing model. What is the most direct way to accomplish this in Databricks AutoML?

Accepted Answer

Open the auto-generated notebook for the best trial from the AutoML experiment page, which contains the full source code for that model

Answer

Re-run the AutoML experiment with autologging enabled to capture the source code as an MLflow artifact

Answer

Download the registered model from Unity Catalog and decompile the serialized model file to inspect its code

Answer

Inspect the data exploration notebook, which contains the training code for every trial in the experiment

Question 3

A data scientist runs a Databricks AutoML classification experiment on a highly imbalanced dataset where only 4% of records belong to the positive (fraud) class. After the experiment completes, they open the AutoML UI to evaluate the trained models. Which behavior should they expect from AutoML regarding how it handles this imbalanced dataset and reports its results?

Accepted Answer

AutoML automatically detects the class imbalance, applies a balancing technique to the majority class in the training data, and surfaces this in the experiment's data exploration notebook.

Answer

AutoML requires the user to manually oversample the minority class before starting the experiment; otherwise it aborts with an error.

Answer

AutoML only supports balanced datasets and will silently drop the experiment if the class ratio exceeds a threshold.

Answer

AutoML ignores class distribution entirely and evaluates all models solely by overall accuracy, with no imbalance handling.

Question 4

A data scientist launches a Databricks AutoML classification experiment through the UI on a customer churn dataset. Before reviewing model results, they want to understand data quality issues such as missing values, high-cardinality columns, and column correlations that AutoML detected during preprocessing. Which artifact should they open to find this information?

Accepted Answer

The data exploration notebook automatically generated by AutoML at the top of the experiment page

Answer

The MLflow run artifacts of the best-performing model

Answer

The generated notebook for the best trial, in its model training cells

Answer

The experiment's 'Schema' tab in the Model Registry entry

Question 5

A data scientist launches an AutoML classification experiment through the Databricks AutoML UI on a customer-churn dataset. After the experiment completes, they want to understand exactly what AutoML produced automatically before doing any manual work. Which two artifacts does every completed AutoML experiment generate and expose in the experiment UI?

Accepted Answer

A data exploration notebook and a notebook for the best-performing model trial

Answer

A feature table in Unity Catalog and a registered model version with the Champion alias

Answer

A scheduled retraining job and a serving endpoint for the best model

Answer

A confusion-matrix image artifact and a SHAP dashboard notebook only

Question 6

A data scientist wants to launch an AutoML classification experiment directly from a notebook using the Python API rather than the AutoML UI. They have a Spark DataFrame named `churn_df`, the target column is `churned`, and they want AutoML to stop after 30 minutes. Which code snippet correctly starts the experiment?

Accepted Answer

from databricks import automl
summary = automl.classify(dataset=churn_df, target_col="churned", timeout_minutes=30)

Answer

from databricks import automl
summary = automl.fit(dataset=churn_df, label="churned", problem_type="classification", max_time=30)

Answer

import mlflow
summary = mlflow.automl.classify(data=churn_df, target="churned", timeout=30)

Answer

from databricks import automl
summary = automl.run(df=churn_df, target_col="churned", task="classify", minutes=30)

Question 7

A data scientist launches a Databricks AutoML forecasting experiment through the UI. They notice that AutoML asks them to select a 'time column' but does not offer options to manually configure a random train/validation/test split percentage the way they expect from a classification experiment. Why does AutoML handle the data split differently for this forecasting experiment?

Accepted Answer

For forecasting, AutoML splits the data chronologically based on the time column so that validation and test sets always come after the training period, preserving temporal order.

Answer

For forecasting, AutoML always uses the entire dataset for training and skips validation entirely, so no split configuration is exposed.

Answer

For forecasting, AutoML randomly shuffles rows and applies an 80/20 split identical to classification, but hides the setting to reduce clutter.

Answer

For forecasting, AutoML requires the user to pre-split the data into separate tables before starting the experiment, which is why no split UI appears.

Question 8

A data scientist launches a Databricks AutoML classification experiment through the UI and sets the 'Timeout (minutes)' field to 30. After 30 minutes the experiment stops while several trial runs are still queued. What happens to the results the experiment has produced so far?

Accepted Answer

AutoML returns the best model found within the time limit, and the generated notebooks and logged runs for completed trials remain available.

Answer

The experiment is discarded entirely because it did not run to completion, and no notebooks or metrics are saved.

Answer

AutoML automatically extends the timeout until all queued trials finish before returning any results.

Answer

Only the data exploration notebook is retained; all model trial runs are deleted when the timeout is reached.

Question 9

A data analyst wants to quickly benchmark several models for a customer churn classification problem using the Databricks AutoML UI. They have a Delta table registered in Unity Catalog and want AutoML to automatically try multiple algorithms and generate reproducible notebooks. When configuring the AutoML experiment through the UI, which combination of settings must they specify for the experiment to run correctly?

Accepted Answer

The ML problem type (Classification), the input training dataset, and the prediction target column

Answer

The prediction target column, a pre-trained baseline model, and a manually written evaluation notebook

Answer

The ML problem type (Classification), the MLflow Model Registry alias, and the number of Spark executors

Answer

A feature table lookup key, the primary metric only, and a published online store endpoint

Question 10

A demand-planning team wants to use Databricks AutoML through the UI to forecast weekly product sales for the next 12 weeks. Their Delta table contains a 'sales_date' column, a numeric 'units_sold' column, and a 'store_id' column identifying 40 different stores, each with its own time series. Which configuration is required for the AutoML forecasting experiment to produce separate forecasts per store?

Accepted Answer

Set 'units_sold' as the prediction target, 'sales_date' as the time column, and specify 'store_id' as the identity (time series identifier) column, with a horizon of 12 and frequency of weeks.

Answer

Set 'units_sold' as the prediction target, 'sales_date' as the time column, and leave the identity column blank so AutoML automatically detects the 40 series.

Answer

Run 40 separate classification experiments, one per store, each filtered to a single 'store_id'.

Answer

Set 'store_id' as the prediction target and 'sales_date' as the time column, using a horizon of 12 weeks.

Question 11

A data scientist launches a Databricks AutoML forecasting experiment through the UI on a table of daily retail sales. After the experiment completes, they want to understand how far into the future the best model can predict and how AutoML determined the number of future periods to generate. Which combination of AutoML forecasting configuration settings controls the number of future time steps produced by the resulting model?

Accepted Answer

The forecast frequency (e.g., daily) and the forecast horizon, which together define how many future periods are generated

Answer

The primary metric and the timeout, which cap how many future periods the model can produce

Answer

The number of trials and the training/validation split ratio, which determine the future window size

Answer

The time column data type and the country holidays setting, which set the prediction length automatically

Question 12

A data scientist runs a Databricks AutoML classification experiment. After it completes, they want to improve on the best model by manually adjusting a preprocessing step and re-tuning some hyperparameters, while keeping AutoML's automatically generated feature engineering as a starting point. What is the recommended way to do this within the AutoML workflow?

Accepted Answer

Open the generated source-code notebook for the best trial, clone or edit it, and modify the preprocessing and hyperparameters directly since AutoML uses a glass-box approach

Answer

Re-run the AutoML experiment with a longer timeout, because AutoML will eventually discover the manual changes on its own

Answer

Export the best model as a black-box artifact from the Model Registry and retrain it externally, since AutoML notebooks are read-only and cannot be modified

Answer

Delete the AutoML experiment and rebuild the entire pipeline from scratch in a new notebook without any AutoML assistance

Question 13

A data scientist launches an AutoML regression experiment through the Databricks UI to predict housing prices. After the experiment starts, they want to review how AutoML profiled the input dataset — including missing value counts, feature distributions, and detected column types — before any models were trained. Which AutoML-generated artifact should they open?

Accepted Answer

The data exploration notebook automatically generated at the start of the experiment

Answer

The best trial notebook linked from the top-performing run

Answer

The MLflow run's metrics tab for the primary run

Answer

The model artifact's MLmodel file in the run's artifacts

Question 14

A data scientist launches a Databricks AutoML regression experiment through the UI to predict house prices. They want AutoML to rank and select the best trial based on how well predictions match actual values on a scale that penalizes larger errors more heavily, expressed in the same units as the target. Which primary evaluation metric should they configure for the experiment?

Accepted Answer

Root mean squared error (RMSE)

Answer

R-squared (R2)

Answer

F1 score

Answer

Mean absolute error (MAE)

Question 15

A data scientist is preparing a customer churn dataset. The 'age' feature is continuous and highly right-skewed, and the team wants to convert it into categorical bins so that each bin contains roughly the same number of customers, which will help a downstream tree ensemble handle the skew more evenly. Which binning strategy should they apply?

Accepted Answer

Quantile (equal-frequency) binning, which places cut points so each bin holds approximately the same number of records

Answer

Equal-width binning, which divides the age range into intervals of identical size

Answer

Standard scaling the age column so it has mean 0 and standard deviation 1

Answer

One-hot encoding the raw age values as-is into indicator columns

Question 16

A data scientist wants to start a new interactive cluster to train a scikit-learn model and track it with MLflow autologging, using libraries like TensorFlow and XGBoost without manually installing them. When creating the cluster, which choice ensures these ML libraries and MLflow come preinstalled?

Accepted Answer

Select the Databricks Runtime for Machine Learning (Databricks Runtime ML)

Answer

Select a standard Databricks Runtime and add the libraries via an init script

Answer

Select a standard Databricks Runtime and enable Photon acceleration

Answer

Select a standard Databricks Runtime and install libraries with %pip in the notebook

Question 17

During exploratory data analysis on a Spark DataFrame of customer records, a data scientist computes summary statistics with df.describe() and notices that the numeric column 'account_region_code' has a standard deviation of 0.0 and identical min, max, and mean values across all 500,000 rows. What is the most appropriate action to take before model training?

Accepted Answer

Drop the column, because a feature with zero variance provides no discriminative information for the model

Answer

Apply StandardScaler to the column so its variance is normalized to 1.0 before training

Answer

Impute the column values with the median to introduce variability into the feature

Answer

Keep the column and apply one-hot encoding since it appears to be a categorical identifier

Question 18

A data scientist is preparing features for a linear regression model that predicts house prices. During EDA, they compute a Pearson correlation matrix and notice that 'total_square_feet' and 'number_of_rooms' have a correlation coefficient of 0.94 with each other, while each correlates around 0.60 with the target price. What is the most appropriate action to take before training the linear model?

Accepted Answer

Drop one of the two highly correlated features (or combine them) to reduce multicollinearity between predictors

Answer

Drop both features because their correlation with the target is only moderate (0.60)

Answer

Keep both features unchanged, since high correlation between predictors improves a linear model's accuracy

Answer

Apply StandardScaler to both features, which will eliminate the correlation between them

Question 19

A data scientist is building a regression model on a small dataset of only 300 labeled records. A single 80/20 train/test split produces validation metrics that vary widely each time the seed changes, making it hard to trust the model's estimated performance. The scientist wants a more reliable estimate of generalization error before registering the model. Which change to the training/validation strategy best addresses this problem?

Accepted Answer

Use k-fold cross-validation (e.g., 5-fold) so every record is used for both training and validation across folds, then average the metrics

Answer

Increase the test split from 20% to 50% so the validation set is larger and more stable

Answer

Remove the random seed entirely so results reflect natural variability

Answer

Train on 100% of the data and report the training-set metric as the performance estimate

Question 20

A data scientist working in a Databricks notebook on a Databricks Runtime for ML cluster wants to reuse a set of helper functions that are defined in a separate notebook named 'utils' located in the same workspace folder. They want the functions to become directly callable in their current notebook's Python session. Which approach accomplishes this?

Accepted Answer

Use the magic command %run ./utils at the top of the current notebook

Answer

Use dbutils.notebook.run('./utils', 60) to import the functions

Answer

Use the magic command %pip install ./utils to load the helper notebook

Answer

Use import utils as a standard Python module import

Question 21

A data scientist is setting up a new cluster to train a deep learning model with TensorFlow and track experiments with MLflow. They want an environment where common ML libraries and MLflow are preinstalled and GPU support is available without manual pip installs or configuration. Which cluster configuration best satisfies these requirements?

Accepted Answer

A cluster running the Databricks Runtime for Machine Learning (GPU variant)

Answer

A cluster running the standard Databricks Runtime, with TensorFlow and MLflow installed via a cluster-scoped init script

Answer

A cluster running the standard Databricks Runtime, installing all libraries through %pip in the notebook

Answer

A SQL warehouse configured with a GPU-backed compute profile

Question 22

A retail analytics team needs to score customer churn predictions for its entire 40-million-row customer base once every night. The results are written to a Delta table that a BI dashboard reads the next morning. There is no requirement for sub-second response times, and no external application calls the model interactively. Which deployment paradigm best fits this workload?

Accepted Answer

Batch inference using an MLflow model loaded as a Spark UDF over the full customer DataFrame

Answer

Real-time inference via a Databricks Model Serving endpoint queried per customer

Answer

Streaming inference with Structured Streaming reading from a continuous source

Answer

Real-time serving with an autoscaling endpoint behind a REST API gateway

Question 23

During exploratory data analysis on a housing dataset, an analyst computes a covariance matrix between 'square_footage' (measured in thousands of square feet) and 'lot_size' (measured in acres). The covariance value is 45.2, and the analyst wants to determine the strength of the linear relationship between the two features to decide whether one is redundant. Why is the correlation coefficient a more appropriate metric than the raw covariance value here?

Accepted Answer

Correlation is normalized to a range between -1 and 1, making it comparable across features with different units and scales, whereas covariance magnitude depends on the units of measurement.

Answer

Correlation can detect non-linear relationships between features, whereas covariance only measures linear relationships.

Answer

Correlation handles missing values automatically, while covariance requires complete cases and will error on nulls.

Answer

Covariance is always positive and therefore cannot indicate the direction of a relationship, while correlation can.

Question 24

A data scientist runs df.describe() on a Spark DataFrame of loan applications before modeling. For the 'annual_income' column, the summary shows: count = 48,500 (out of 50,000 rows), min = -1, mean = 62,300, 50% (median) = 55,000, max = 9,999,999. Which single observation from these statistics most strongly indicates a data quality problem that should be investigated before feature engineering?

Accepted Answer

The min value of -1 is present, since annual income cannot logically be negative.

Answer

The mean (62,300) is higher than the median (55,000), which proves the data is corrupted.

Answer

The count of 48,500 is fine because Spark automatically imputes the 1,500 missing values.

Answer

The max of 9,999,999 confirms the column must be dropped because it contains only outliers.

Question 25

A data scientist is building a scikit-learn pipeline to preprocess a dataset before training a logistic regression model. The dataset contains numeric features with widely different ranges and several rows with missing values in those numeric columns. The scientist wants to (1) impute missing numeric values with the column median and (2) standardize the features. To avoid data leakage and produce correct results, in what order should these steps be arranged inside the pipeline, and how should they be fit?

Accepted Answer

Fit the median imputer first, then the StandardScaler, chaining both inside a single Pipeline that is fit only on the training data.

Answer

Fit the StandardScaler first on the full dataset, then impute missing values with the median so the scaler sees complete data.

Answer

Impute and scale the entire dataset before performing the train/test split so both sets share identical statistics.

Answer

Fit the imputer and scaler separately on both the training and test sets so each set is scaled to its own distribution.

Question 26

A data scientist is using a Databricks Feature Engineering client to build a training dataset. They call fe.create_training_set() with a DataFrame containing a 'customer_id' column and several FeatureLookup objects that pull columns from a feature table keyed on 'customer_id'. When they later call fe.log_model() and score new data with fe.score_batch(), they want the model to automatically retrieve the looked-up features at inference time using only the raw input containing 'customer_id'. Which behavior of the returned TrainingSet supports this workflow?

Accepted Answer

The TrainingSet packages the feature lookup metadata so that a model logged with fe.log_model() records the feature table dependencies and can rehydrate features automatically during fe.score_batch().

Answer

The TrainingSet materializes the joined features into a new permanent Unity Catalog table that fe.score_batch() must be pointed to explicitly at inference time.

Answer

The TrainingSet requires the data scientist to manually re-join the feature table during scoring because lookup metadata is not persisted with the model.

Answer

The TrainingSet strips the 'customer_id' lookup key from the training DataFrame, so it must be re-added by hand before calling fe.score_batch().

Question 27

A data scientist has created a feature table in Unity Catalog named prod.retail.customer_features with primary key customer_id. They build a FeatureLookup to join these features onto a labeled training DataFrame using FeatureEngineeringClient.create_training_set(). When they call training_set.load_df(), the resulting DataFrame contains null values for all feature columns even though the feature table is fully populated. What is the most likely cause?

Accepted Answer

The lookup_key specified in the FeatureLookup does not match the values or column present in the labeled DataFrame, so no rows join to the feature table's primary key.

Answer

The feature table must be published to an online store before create_training_set() can retrieve any values.

Answer

MLflow autologging was disabled, which prevents the Feature Engineering client from reading feature values.

Answer

The Databricks Runtime for ML version is too old to support Unity Catalog feature tables, silently returning nulls.

Question 28

A data scientist is building a training dataset using a Databricks Feature Store feature table that stores time-varying customer metrics (e.g., rolling 30-day spend) with a timestamp column. Each training label event also has its own event timestamp. When creating the training set with FeatureLookup, the scientist wants to ensure that each label row is joined only with feature values that were known at or before the label's event time, preventing data leakage from future feature updates. Which approach correctly achieves this?

Accepted Answer

Specify the timestamp_lookup_key in the FeatureLookup so the feature table is joined using a point-in-time lookup against the label's event timestamp.

Answer

Filter the feature table to keep only the most recent row per primary key before creating the training set.

Answer

Sort the training DataFrame by timestamp and use a standard inner join on the primary key only.

Answer

Enable online serving on the feature table so historical values are automatically time-aligned.

Question 29

A data scientist creates a feature table in Unity Catalog containing customer aggregates keyed by customer_id. They train a model using a FeatureLookup so that the training set joins these features automatically. When the model is later deployed for batch inference, the inference DataFrame only contains customer_id and a few raw request columns. Which behavior should the data scientist expect when using score_batch (or the equivalent Feature Engineering scoring API) with this logged model?

Accepted Answer

The scoring API automatically retrieves the required features from the feature table using customer_id, so the inference DataFrame does not need to include the looked-up feature columns.

Answer

The inference DataFrame must contain all feature columns because the model does not store any information about the feature lookups used during training.

Answer

The features must be manually joined to the inference DataFrame before scoring, since feature metadata is discarded once the model is logged.

Answer

Batch inference will fail unless the feature table is first exported to an online store, because offline feature tables cannot be used at scoring time.

Question 30

A data engineer maintains a feature table `main.retail.customer_features` in Unity Catalog. Each night, a job computes updated aggregate features (e.g., 30-day spend) for a subset of customers whose activity changed that day. Existing feature rows for customers with no activity must remain unchanged, and updated customers should have their existing rows overwritten with fresh values. Which approach correctly updates the feature table using the FeatureEngineeringClient?

Accepted Answer

Call `fe.write_table(name='main.retail.customer_features', df=updated_df, mode='merge')` so only the provided rows are upserted by primary key while other rows are preserved.

Answer

Call `fe.write_table(name='main.retail.customer_features', df=updated_df, mode='overwrite')` to replace the whole table each night.

Answer

Call `fe.create_table(...)` again each night with the updated DataFrame to append the new rows.

Answer

Use `spark.write.mode('append').saveAsTable('main.retail.customer_features')` to add the updated rows directly.

Question 31

A data scientist wants to create a new feature table in Unity Catalog from a Spark DataFrame that contains one row per customer, keyed by 'customer_id'. They plan to use these features later for training and batch scoring via feature lookups. Which approach correctly creates the feature table?

Accepted Answer

Use FeatureEngineeringClient.create_table(), specifying the table name, primary_keys='customer_id', and the DataFrame via the df argument

Answer

Save the DataFrame with df.write.saveAsTable() and then run ALTER TABLE to designate it as a feature table

Answer

Call mlflow.log_table() with the DataFrame and pass primary_keys='customer_id' as an artifact parameter

Answer

Use FeatureEngineeringClient.write_table() without defining any primary key, since Unity Catalog infers keys automatically

Question 32

A data scientist has a Spark DataFrame containing sales data for 500 retail stores, with columns store_id, week, features, and target. They want to train a separate scikit-learn regression model for each store in parallel across the cluster, returning a DataFrame with one row per store containing the store_id and its model's RMSE. Which approach correctly accomplishes this in a single distributed operation?

Accepted Answer

Group the DataFrame by store_id and call applyInPandas, passing a function that trains a scikit-learn model on the group's pandas DataFrame and returns a pandas DataFrame, along with an explicit output schema.

Answer

Use a pandas_udf of type SCALAR that accepts the features column and returns predictions, then aggregate the RMSE per store afterward.

Answer

Collect the Spark DataFrame to the driver with toPandas(), loop over each store_id, and train a scikit-learn model for each in a Python for-loop.

Answer

Convert the DataFrame using the pandas API on Spark and call .groupby('store_id').apply() with a scikit-learn training function.

Question 33

A data scientist is tuning hyperparameters for a scikit-learn gradient boosting model on a single large Databricks cluster. The training dataset fits comfortably in the driver's memory, and each individual model trains quickly on one machine. They want to use Hyperopt to evaluate many hyperparameter combinations and distribute those evaluations across the cluster's worker nodes to finish the search faster. Which Hyperopt configuration should they use in the fmin() call?

Accepted Answer

Pass trials=SparkTrials() so that individual hyperparameter evaluations are distributed across the cluster's workers.

Answer

Pass trials=Trials() because it automatically parallelizes evaluations across Spark executors.

Answer

Convert the pandas DataFrame to a Spark DataFrame and train a Spark ML model so Hyperopt can distribute the data.

Answer

Wrap the training function in a pandas UDF and pass trials=Trials() to run each trial on a separate partition.

Question 34

A data scientist is using Hyperopt's fmin() with the TPE algorithm to tune a scikit-learn classifier. The objective is to maximize validation accuracy. Inside the objective function, the model is trained and cross-validated, producing a mean accuracy score stored in a variable named acc. What should the objective function return so that Hyperopt tunes the model correctly?

Accepted Answer

return {'loss': -acc, 'status': STATUS_OK}

Answer

return {'loss': acc, 'status': STATUS_OK}

Answer

return {'accuracy': acc, 'status': STATUS_OK}

Answer

return acc

Question 35

A data scientist is tuning an XGBoost model on a single-node Databricks cluster using Hyperopt. They define a search space, an objective function that returns a dictionary with keys 'loss' and 'status', and call fmin() with the TPE algorithm. They want the optimization to try exactly 60 different hyperparameter configurations before stopping. Which fmin() argument controls this behavior?

Accepted Answer

Set max_evals=60

Answer

Set the parallelism argument on SparkTrials to 60

Answer

Set trials=Trials(60)

Answer

Set the timeout argument to 60

Question 36

A data scientist is using Hyperopt to tune a gradient boosting model. They want to search for the learning rate over a range from 0.001 to 0.1, and they know that this parameter's effect is multiplicative rather than additive—values like 0.001, 0.01, and 0.1 should each get comparable exploration. Which search space definition should they use for the learning rate?

Accepted Answer

hp.loguniform('learning_rate', np.log(0.001), np.log(0.1))

Answer

hp.uniform('learning_rate', 0.001, 0.1)

Answer

hp.quniform('learning_rate', 0.001, 0.1, 0.01)

Answer

hp.choice('learning_rate', [0.001, 0.1])

Question 37

A data scientist is tuning an XGBoost model with 5 continuous hyperparameters, each spanning a wide range. They have a limited compute budget and want to find strong hyperparameter values with far fewer trials than an exhaustive approach would require. Which tuning strategy is the BEST fit, and why?

Accepted Answer

Use Hyperopt with the Tree-structured Parzen Estimator (TPE) algorithm, because it uses results from prior trials to choose promising hyperparameter values, converging with fewer evaluations.

Answer

Use an exhaustive grid search, because evaluating every combination guarantees the global optimum within the budget.

Answer

Use pure random search with a fixed large number of trials, because random sampling always outperforms adaptive methods for continuous spaces.

Answer

Use Hyperopt with the random sampling (rand.suggest) algorithm, because it adapts the search distribution based on prior trial losses.

Question 38

A data scientist runs Hyperopt's fmin() on a single-node cluster to tune an XGBoost model, passing a Trials() object as the trials argument. After optimization completes, they want to programmatically inspect the loss and hyperparameters tried for every evaluation, not just the best result returned by fmin(). Which approach lets them access the full history of all trials?

Accepted Answer

Iterate over the Trials object's .results and .trials attributes, which store the returned dictionary and parameters for each evaluation

Answer

The return value of fmin() already contains a list of every trial's loss and parameters, so no further object is needed

Answer

Re-run fmin() with return_argmin=False to have it return the complete evaluation history instead of the best point

Answer

Replace Trials() with SparkTrials(), which is the only Trials type that records per-evaluation history

Question 39

During exploratory data analysis on a Spark DataFrame of loan applications, a data scientist wants to flag outliers in the 'annual_income' column using the interquartile range (IQR) method. They compute Q1 (25th percentile) = 40,000 and Q3 (75th percentile) = 90,000. Using the standard IQR rule, which values should be considered outliers?

Accepted Answer

Values below -35,000 or above 165,000

Answer

Values below 40,000 or above 90,000

Answer

Values below 15,000 or above 115,000

Answer

Values more than 2 standard deviations from the mean

Question 40

A data scientist is preparing a numeric feature, annual_income, that contains missing values in a customer churn dataset. They plan to impute the missing values with the median before training a model. They have already split the data into training and test sets. To avoid data leakage while imputing, what is the correct approach?

Accepted Answer

Compute the median from the training set only, then use that value to fill missing values in both the training and test sets

Answer

Compute the median from the full dataset before splitting, then fill missing values in both sets

Answer

Compute a separate median from the training set and another from the test set, filling each set with its own median

Answer

Drop all rows with missing annual_income values from both the training and test sets

Question 41

A data scientist has computed a Python dictionary containing per-class precision and recall values that they want to persist with the current MLflow run as a JSON artifact. They want the cleanest approach that stores the dictionary directly as a named JSON file in the run's artifact store without manually writing a temporary file to local disk first. Which MLflow call should they use inside the active run?

Accepted Answer

mlflow.log_dict(metrics_dict, "per_class_metrics.json")

Answer

mlflow.log_metric("per_class_metrics", metrics_dict)

Answer

mlflow.log_param("per_class_metrics", metrics_dict)

Answer

mlflow.log_artifact(metrics_dict, "per_class_metrics.json")

Question 42

A data scientist finished a training run tracked in MLflow. She now wants to programmatically download a preprocessing pipeline object (saved earlier with mlflow.log_artifact under the path 'preprocessing/pipeline.pkl') from that specific run so she can reuse it in a separate notebook. She has the run_id. Which approach correctly retrieves the artifact file to local storage?

Accepted Answer

Use mlflow.artifacts.download_artifacts(run_id=run_id, artifact_path='preprocessing/pipeline.pkl') to download the file locally

Answer

Call mlflow.get_run(run_id).data.artifacts['preprocessing/pipeline.pkl'] to read the object directly into memory

Answer

Use mlflow.pyfunc.load_model(f'runs:/{run_id}/preprocessing/pipeline.pkl') to load the pipeline

Answer

Query mlflow.search_runs() and access the returned DataFrame column 'artifacts.preprocessing.pipeline.pkl'

Question 43

A data scientist is starting a new project in a Databricks notebook and wants every scikit-learn model training call to be tracked automatically, including parameters, metrics, and the fitted model, without wrapping each training call in explicit logging code. They also want all runs to be recorded under a specific experiment they created in the workspace. Which combination of steps accomplishes this with the least manual logging effort?

Accepted Answer

Call mlflow.set_experiment() with the experiment path, then call mlflow.sklearn.autolog() before fitting the estimators.

Answer

Call mlflow.start_run() manually around each .fit() call and use mlflow.log_param() and mlflow.log_metric() for every value.

Answer

Set the experiment with mlflow.set_experiment(), then call mlflow.log_model() after each .fit() to capture parameters and metrics.

Answer

Call mlflow.autolog(disable=True) and register the model directly to Unity Catalog after training.

Question 44

A data scientist trains a scikit-learn RandomForestClassifier inside a notebook. Before calling model.fit(), they run mlflow.sklearn.autolog(). After training completes, they want to programmatically inspect the training metrics and parameters that were automatically captured for that run, without opening the MLflow UI. Which approach retrieves this information correctly?

Accepted Answer

Use mlflow.get_run(run_id) and read the returned Run object's data.metrics and data.params attributes.

Answer

Call mlflow.sklearn.load_model(model_uri) and read the metrics from the loaded model object's .metrics_ attribute.

Answer

Query the cluster's Spark session with spark.read.format('mlflow').load() to return a DataFrame of parameters and metrics.

Answer

Re-run mlflow.sklearn.autolog() a second time, which prints all captured metrics and parameters to the notebook cell output.

Question 45

A data scientist enables MLflow autologging for scikit-learn and trains a RandomForestClassifier inside a `with mlflow.start_run()` block. After the model fits, they compute a custom business metric (weighted profit) and want it logged to the SAME run that autologging created, alongside the automatically captured parameters and metrics. What should they do?

Accepted Answer

Call `mlflow.log_metric("weighted_profit", value)` inside the same `with mlflow.start_run()` block after the model is trained.

Answer

Start a second `mlflow.start_run()` block after training and call `mlflow.log_metric` there, since autologging closes the first run automatically.

Answer

Set `mlflow.sklearn.autolog(log_custom_metrics=True)` so the profit metric is captured automatically.

Answer

Disable autologging first, then manually log all parameters, metrics, and the custom metric to guarantee they land in one run.

Question 46

A data scientist trains a scikit-learn RandomForestClassifier inside an MLflow run with autologging enabled. After training completes, they open the run in the MLflow UI and want to confirm which value was logged as a parameter versus a metric. Which of the following was recorded as a parameter (not a metric) by MLflow autologging?

Accepted Answer

n_estimators, the number of trees specified when constructing the model

Answer

training_accuracy_score computed on the training data

Answer

training_f1_score computed on the training data

Answer

training_log_loss computed on the training data

Question 47

A data scientist is training a scikit-learn RandomForestClassifier inside a Databricks notebook. They want MLflow to automatically capture the model's hyperparameters, training metrics, and the fitted model artifact without adding explicit mlflow.log_param or mlflow.log_metric calls around their existing training code. What is the minimal change they should make before calling model.fit()?

Accepted Answer

Call mlflow.sklearn.autolog() before the fit call

Answer

Wrap the fit call in a with mlflow.start_run() block and manually call mlflow.sklearn.log_model()

Answer

Set mlflow.set_experiment() and call mlflow.log_artifacts() after fitting

Answer

Register the model in Unity Catalog with mlflow.register_model() before training

Question 48

A data scientist is training an XGBoost model inside a Databricks notebook and wants MLflow to automatically capture hyperparameters and evaluation metrics for each run. However, because the models are very large and storage is a concern, they do NOT want the fitted model artifact itself to be logged automatically. Which approach accomplishes this?

Accepted Answer

Call mlflow.xgboost.autolog(log_models=False) before training so parameters and metrics are captured but the model artifact is not logged.

Answer

Call mlflow.autolog(disable=True) to prevent artifact bloat while still capturing parameters and metrics.

Answer

Set mlflow.xgboost.autolog(log_input_examples=False) so the model artifact is skipped while metrics are recorded.

Answer

Manually wrap training in mlflow.start_run() and call mlflow.log_params() only, since autologging always logs the model artifact.

Question 49

A data scientist is training a scikit-learn RandomForestClassifier inside a Databricks notebook. Before fitting the model, they call mlflow.sklearn.autolog(). They then wrap the training code in an explicit `with mlflow.start_run() as run:` block and call model.fit(). After the cell completes, what will MLflow have logged automatically to that run?

Accepted Answer

The model's hyperparameters, training metrics, and the fitted model artifact, all captured to the active run without additional logging calls

Answer

Only the model artifact; parameters and metrics must still be logged manually with mlflow.log_param and mlflow.log_metric

Answer

Nothing, because autolog() only works when start_run() is not called explicitly

Answer

Only the hyperparameters, since autologging cannot compute metrics without an explicit evaluation dataset

Question 50

A data scientist has run 30 experiments to tune a gradient boosting classifier, and each run logged parameters and metrics (including validation AUC) to the same MLflow experiment. They now want to programmatically identify the single run with the highest validation AUC so they can register that run's model. Which approach accomplishes this most directly?

Accepted Answer

Use mlflow.search_runs() on the experiment and sort the returned DataFrame by the metrics.val_auc column in descending order, then take the top row's run_id.

Answer

Open each run individually in the MLflow UI and manually copy the run_id of the run with the highest AUC into the registration code.

Answer

Call mlflow.get_run() with no arguments to automatically return the best-performing run in the active experiment.

Answer

Re-run all 30 experiments with autologging enabled so MLflow automatically flags the best run in the experiment metadata.

Question 51

A data scientist has registered a model as `main.ml.churn_model` (version 3) in Unity Catalog. They want to programmatically create a Databricks Model Serving endpoint from a notebook using the MLflow Deployments SDK so the model can serve real-time requests. Which approach correctly references the Unity Catalog model in the endpoint configuration?

Accepted Answer

Use `get_deploy_client("databricks")` and pass `served_entities` with `entity_name="main.ml.churn_model"` and `entity_version="3"`.

Answer

Use `mlflow.pyfunc.load_model("models:/main.ml.churn_model/3")` and call `.serve()` on the returned model object.

Answer

Register the model to the Workspace Model Registry first, then pass `model_name` and `model_version` to `get_deploy_client("local")`.

Answer

Use `spark_udf` to wrap the model and expose it as a Spark temporary view for streaming queries.

Question 52

A data scientist logged a scikit-learn model to an MLflow run using autologging. A downstream engineer now needs to load that logged model and generate predictions on a new pandas DataFrame in a separate notebook, without needing to know which underlying ML framework was used. Which approach should the engineer use to load the model in the most framework-agnostic way?

Accepted Answer

Load the model with mlflow.pyfunc.load_model(model_uri) and call the returned model's .predict(df) method

Answer

Load the model with mlflow.sklearn.load_model(model_uri) and call the returned estimator's .predict(df) method

Answer

Download the model.pkl artifact directly and unpickle it with Python's pickle.load before calling .predict(df)

Answer

Register the model to Unity Catalog first, then query it exclusively through the online serving REST endpoint

Question 53

A data scientist has trained a scikit-learn classifier inside an MLflow run and generated a confusion matrix plot saved locally as 'confusion_matrix.png'. They want this image to be stored with the run so teammates can view it in the MLflow UI under the run's artifacts. Which MLflow API call should they use inside the active run?

Accepted Answer

mlflow.log_artifact('confusion_matrix.png')

Answer

mlflow.log_metric('confusion_matrix', 'confusion_matrix.png')

Answer

mlflow.log_param('confusion_matrix', 'confusion_matrix.png')

Answer

mlflow.set_tag('confusion_matrix', 'confusion_matrix.png')

Question 54

A data scientist is training a churn model in a Databricks notebook. They rely on MLflow autologging for a scikit-learn model, but they also compute a custom business metric called 'expected_revenue_saved' after the model is fit. They want this custom metric to appear in the same MLflow run that autologging created, alongside the automatically captured parameters and metrics. What is the correct approach?

Accepted Answer

Wrap the training and the custom metric logging inside a single `with mlflow.start_run():` block, calling `mlflow.log_metric('expected_revenue_saved', value)` after `model.fit()`.

Answer

Call `mlflow.log_metric('expected_revenue_saved', value)` in a separate cell after training; autologging will automatically attach it to the previous run.

Answer

Disable autologging entirely and manually log all parameters and metrics, since autologging and manual logging cannot be combined in one run.

Answer

Use `mlflow.start_run(nested=True)` to create a child run specifically for the custom metric so it does not conflict with the autologged run.

Question 55

A data scientist is manually logging a scikit-learn model with MLflow and wants the Model Registry UI to display the expected input schema and a sample record so downstream consumers can understand how to call the model. Which addition to the mlflow.sklearn.log_model() call best accomplishes this?

Accepted Answer

Pass signature and input_example parameters, inferring the signature with mlflow.models.infer_signature() from the training features and predictions

Answer

Set the registered_model_name parameter so the schema is generated automatically during registration

Answer

Log the training DataFrame as a separate artifact using mlflow.log_artifact() alongside the model

Answer

Add the feature column names as tags on the run using mlflow.set_tags()

Question 56

A data scientist registered a model in Unity Catalog under the name `main.ml.churn_model`. Six months later, an auditor asks the team to identify exactly which experiment run produced version 3 of this model, including the parameters and metrics logged during training. Which approach lets the team trace this information most directly?

Accepted Answer

Open the model version 3 details in the Models UI (or query it via the MLflow client) and follow the source run link, which points to the originating MLflow run containing the logged parameters and metrics.

Answer

Re-run the training notebook with the same code to reproduce the parameters and metrics, since Unity Catalog does not store any link between a model version and its training run.

Answer

Search the Delta transaction log of the feature table used for training to reconstruct the parameters and metrics associated with version 3.

Answer

Inspect the cluster event logs from the time the model was registered to find the parameters and metrics that were used.

Question 57

A team stores its models in Unity Catalog. A data scientist has just registered version 7 of the model 'main.ml.churn_model' and wants to promote it so that a downstream batch scoring job automatically picks up this new version without changing the job's code. The job loads the model using the URI 'models:/main.ml.churn_model@Champion'. What is the correct action to ensure the batch job uses version 7?

Accepted Answer

Assign the 'Champion' alias to version 7 of the model using MlflowClient.set_registered_model_alias().

Answer

Transition version 7 to the 'Production' stage using MlflowClient.transition_model_version_stage().

Answer

Re-register the model so version 7 automatically becomes the latest and is loaded by the '@Champion' URI.

Answer

Add a tag 'Champion=true' to version 7 with MlflowClient.set_model_version_tag().

Question 58

A data science team has registered a model named `main.ml.churn_model` in Unity Catalog. The production deployment pipeline should always load the version currently designated as the production candidate, which the team marks using the alias `Champion`. Which code snippet correctly loads that specific model version for batch inference?

Accepted Answer

mlflow.pyfunc.load_model("models:/main.ml.churn_model@Champion")

Answer

mlflow.pyfunc.load_model("models:/main.ml.churn_model/Champion")

Answer

mlflow.pyfunc.load_model("models:/main.ml.churn_model/Production")

Answer

mlflow.pyfunc.load_model("models:/main.ml.churn_model:Champion")

Question 59

A data scientist has registered a model named 'churn_model' in Unity Catalog. After validating a new version, they want to load the specific model version that the team currently treats as the production deployment for real-time inference. The team uses the alias 'Champion' to mark the production-ready version. Which URI should they use to load this model with the MLflow client?

Accepted Answer

models:/main.default.churn_model@Champion

Answer

models:/main.default.churn_model/Production

Answer

runs:/main.default.churn_model/Champion

Answer

models:/main.default.churn_model/Champion

Question 60

A data scientist has trained a churn-prediction model and logged it to an MLflow run in a workspace where Unity Catalog is the configured model registry. She wants to register the logged model so that it is governed by Unity Catalog. Which model name argument must she pass to mlflow.register_model() for the registration to succeed?

Accepted Answer

A three-level name in the form catalog.schema.model_name, e.g. 'prod.ml_models.churn_model'

Answer

A single-level name, e.g. 'churn_model', because Unity Catalog resolves the catalog automatically

Answer

A two-level name in the form schema.model_name, e.g. 'ml_models.churn_model'

Answer

A four-level name including the workspace, e.g. 'workspace.prod.ml_models.churn_model'

Question 61

A data scientist is running a hyperparameter tuning job that trains 20 different model configurations within a single Python function. They want each configuration's parameters and metrics tracked separately in MLflow, but also want all 20 trials grouped under one logical parent run in the experiment UI for easy comparison. Which MLflow approach accomplishes this?

Accepted Answer

Start a parent run with mlflow.start_run(), then start each trial with mlflow.start_run(nested=True) inside the parent's context

Answer

Call mlflow.set_experiment() 20 times, once per trial, so each configuration gets its own experiment folder

Answer

Log all 20 configurations into a single run using mlflow.log_params() with a dictionary containing all parameter combinations

Answer

Use mlflow.autolog() alone, which automatically creates a parent-child hierarchy for any tuning loop

Question 62

A data scientist has trained a scikit-learn classifier and logged it as an artifact within an MLflow run. The team now wants to register this model in Unity Catalog so that downstream consumers can reference it by a three-level name (catalog.schema.model) and automatically capture model lineage back to the originating run. Which approach correctly registers the model into Unity Catalog?

Accepted Answer

Set the MLflow registry URI to 'databricks-uc', then call mlflow.register_model() with the run's model URI (e.g., 'runs:/<run_id>/model') and a three-level name like 'main.ml_team.churn_model'.

Answer

Call mlflow.register_model() using only a two-level name 'ml_team.churn_model' while the registry URI remains set to the default workspace registry.

Answer

Manually copy the model artifact files from DBFS into a Unity Catalog volume, since Unity Catalog cannot track MLflow model versions directly.

Answer

Use mlflow.log_model() with the registered_model_name parameter set to just 'churn_model', which will register it in Unity Catalog by default.

Question 63

A data scientist has trained a fraud-detection model and registered it in Unity Catalog as `prod.fraud.detector`, resulting in version 7. After validating that version 7 outperforms the current production model, they want to programmatically mark version 7 as the model that downstream jobs load via the alias `champion`. Which MlflowClient call accomplishes this?

Accepted Answer

client.set_registered_model_alias(name="prod.fraud.detector", alias="champion", version=7)

Answer

client.transition_model_version_stage(name="prod.fraud.detector", version=7, stage="champion")

Answer

client.set_model_version_tag(name="prod.fraud.detector", version=7, key="alias", value="champion")

Answer

client.update_registered_model(name="prod.fraud.detector", alias="champion", version=7)

Question 64

A data scientist has logged 200 runs to a single MLflow experiment while tuning a gradient boosting model. Each run logged a metric named 'val_rmse' and a parameter named 'max_depth'. The scientist now wants to programmatically retrieve, into a pandas DataFrame, only the runs where max_depth equals 5, sorted so the lowest val_rmse appears first. Which approach accomplishes this?

Accepted Answer

Use mlflow.search_runs() with filter_string="params.max_depth = '5'" and order_by=["metrics.val_rmse ASC"]

Answer

Use mlflow.list_runs() with filter_string="max_depth == 5" and sort_by="val_rmse"

Answer

Use mlflow.search_runs() with filter_string="metrics.max_depth = 5" and order_by=["params.val_rmse ASC"]

Answer

Use mlflow.get_run() in a loop over all run IDs, then filter and sort the resulting list manually with no filter string

Exam domain	Exam weight	Practice
Databricks Machine Learning	38%	Practice this topic
ML Workflows	19%	Practice this topic
Model Development	31%	Practice this topic
Model Deployment	12%	Practice this topic

Databricks Certified Machine Learning Associate (Databricks-ML-Associate) practice exam & study guide

Start studying Databricks-ML-Associate

All Databricks-ML-Associate study resources

Databricks-ML-Associate exam domains

Sample Databricks-ML-Associate questions

Key Databricks-ML-Associate terms

Databricks-ML-Associate frequently asked questions

Databricks Machine Learning (38%)

ML Workflows (19%)

Model Development (31%)

Model Deployment (12%)