Model Deployment — Databricks-ML-Associate Practice Quiz

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 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 3

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 4

A data scientist has a Databricks Model Serving endpoint that currently routes 100% of traffic to version 3 of a registered Unity Catalog model. The team has just trained version 4 and wants to safely evaluate it in production by sending only 10% of live requests to the new version while the remaining 90% continues to hit version 3. What is the recommended way to accomplish this on the existing Model Serving endpoint?

Accepted Answer

Configure the endpoint to serve both model versions as separate served entities and set the traffic percentages in the endpoint's traffic configuration (90% to version 3, 10% to version 4).

Answer

Create a second, independent serving endpoint for version 4 and manually route 10% of client requests to it in application code.

Answer

Assign the 'champion' alias to version 3 and the 'challenger' alias to version 4; Model Serving automatically splits traffic 90/10 between aliases.

Answer

Delete the existing endpoint and recreate it with version 4 only, since Model Serving cannot host more than one model version at a time.

Question 5

A data scientist has deployed a scikit-learn classifier as a Databricks Model Serving endpoint backed by a model registered in Unity Catalog. A downstream application team wants to send inference requests over HTTP. Which approach correctly sends a single-record request to the endpoint's REST API?

Accepted Answer

Send an HTTP POST to the endpoint's invocations URL with a JSON body using the 'dataframe_records' (or 'dataframe_split') key and a valid access token in the Authorization header.

Answer

Send an HTTP GET request to the endpoint URL passing the feature values as query string parameters.

Answer

Call mlflow.pyfunc.spark_udf() against the endpoint URL to distribute the single request across the Spark cluster.

Answer

Write the record to a Delta table and configure the endpoint to poll the table for new rows at a fixed interval.

Question 6

A fraud-detection team must score individual credit-card transactions and return a prediction to the payment application within tens of milliseconds, one transaction at a time, as each purchase occurs. The model is already registered in Unity Catalog. Which deployment paradigm should the team use to meet this requirement?

Accepted Answer

Deploy the model to a Databricks Model Serving endpoint and query it via REST API for each transaction

Answer

Load the model as a Spark UDF and run a nightly batch job over the transactions table

Answer

Use Structured Streaming with a spark_udf reading from a message queue in micro-batches

Answer

Schedule a Databricks Job with applyInPandas to score accumulated transactions every hour

Question 7

A data science team has deployed a fraud-detection model to a Databricks Model Serving endpoint. The model is only queried during business hours, and the team wants to minimize compute costs during nights and weekends when no requests arrive, while still being able to serve requests automatically when traffic resumes. Which endpoint configuration best meets this requirement?

Accepted Answer

Enable the scale-to-zero option on the endpoint so compute is released during idle periods and provisioned again on the next request.

Answer

Set a fixed provisioned concurrency and manually delete the endpoint every evening, recreating it each morning.

Answer

Switch the deployment to a batch inference job using spark_udf scheduled with a Databricks Job.

Answer

Configure the endpoint with the maximum provisioned throughput to reduce per-request cost.

Question 8

A data scientist has trained a scikit-learn model on a single node and registered it with MLflow. They now need to score 500 million rows stored in a Spark DataFrame. They want to apply the model's predictions column-by-column using vectorized operations that process batches of rows as pandas Series for maximum throughput, without grouping the data. Which approach best fits this requirement?

Accepted Answer

Wrap the model in a scalar pandas UDF (pandas_udf) that accepts and returns a pandas Series, and apply it as a column in a Spark select/withColumn call

Answer

Use groupBy().applyInPandas() to distribute the model over grouped partitions of the DataFrame

Answer

Collect the Spark DataFrame to the driver with toPandas() and call model.predict() on the resulting pandas DataFrame

Answer

Convert the Spark DataFrame to an RDD and use map() to call model.predict() on each individual row

Question 9

A data engineer needs to score a 500-million-row Spark DataFrame using a scikit-learn model that was logged with MLflow and registered in Unity Catalog as `main.ml.churn_model` with the alias `champion`. The scoring must run as a distributed batch job on a Spark cluster, and the model expects several feature columns already present in the DataFrame. Which approach correctly applies the registered model for distributed batch inference?

Accepted Answer

Load the model as a Spark UDF with `mlflow.pyfunc.spark_udf(spark, 'models:/main.ml.churn_model@champion')` and apply it to the feature columns with `df.withColumn('prediction', udf(*feature_cols))`.

Answer

Load the model with `mlflow.sklearn.load_model('models:/main.ml.churn_model@champion')` and call `model.predict(df)` directly on the Spark DataFrame.

Answer

Deploy the model to a Databricks Model Serving endpoint and issue one REST request per row of the DataFrame from the driver.

Answer

Convert the Spark DataFrame to a pandas DataFrame with `df.toPandas()`, then call `model.predict()` on the resulting pandas object.

Question 10

A data engineer registered a scikit-learn model in Unity Catalog and wants to score a 200-million-row Delta table stored in the lakehouse. Latency is not a concern, but the job must finish within a scheduled nightly window and leverage the full cluster. Which approach best fits these requirements?

Accepted Answer

Load the model with mlflow.pyfunc.spark_udf() and apply it as a column expression across the Spark DataFrame

Answer

Deploy the model to a Databricks Model Serving endpoint and send each row as a REST request in a loop

Answer

Load the model with mlflow.pyfunc.load_model() on the driver and call .predict() on a pandas conversion of the full table

Answer

Read the table as a Structured Streaming source and apply the model with a stateful streaming aggregation

Question 11

A data engineer needs to score a large Spark DataFrame in a nightly batch job using a model that was registered in Unity Catalog as `prod.ml.churn_model` with the alias `champion`. They plan to use `mlflow.pyfunc.spark_udf` to distribute inference across the cluster. Which code snippet correctly loads the model into a Spark UDF for this batch scoring task?

Accepted Answer

predict_udf = mlflow.pyfunc.spark_udf(spark, model_uri="models:/prod.ml.churn_model@champion")

Answer

predict_udf = mlflow.pyfunc.spark_udf(spark, model_uri="models:/prod.ml.churn_model/champion")

Answer

predict_udf = mlflow.pyfunc.spark_udf(spark, model_uri="runs:/prod.ml.churn_model@champion")

Answer

predict_udf = mlflow.pyfunc.load_model(spark, model_uri="models:/prod.ml.churn_model@champion")

Question 12

A data engineer needs to score a 200-million-row Spark DataFrame using a registered scikit-learn model in Unity Catalog. Before prediction, each row must be enriched by calling a preprocessing function that depends on grouping records by 'store_id' to compute a rolling group-level statistic that the model expects as a feature. The engineer wants the enrichment and prediction to run in a single distributed pass. Which approach best satisfies these requirements?

Accepted Answer

Group the DataFrame by 'store_id' and use applyInPandas with a function that computes the group statistic and calls the loaded model's predict method

Answer

Load the model with mlflow.pyfunc.spark_udf and apply it directly to the DataFrame with a withColumn call

Answer

Collect the DataFrame to the driver, compute the group statistics in pandas, then broadcast the result back for scoring

Answer

Deploy the model to a Databricks Model Serving endpoint and send each row as a REST request from a Spark map operation

Question 13

A data engineer needs to score 500 million records in a nightly Spark batch job using an MLflow model registered in Unity Catalog. Each record must first be grouped by 'store_id' so that a store-specific normalization step (implemented as custom Python logic requiring the full group in memory) is applied before the model's predictions are generated. Which approach correctly handles the per-group preprocessing and inference in a distributed manner?

Accepted Answer

Group the DataFrame by 'store_id' and use applyInPandas with a function that performs the per-group normalization and then calls the loaded model to predict, returning a pandas DataFrame with a defined output schema.

Answer

Use mlflow.pyfunc.spark_udf to load the model and call it directly on the DataFrame, relying on the UDF to group and normalize the data automatically.

Answer

Collect the entire DataFrame to the driver with .toPandas(), apply normalization per group in a loop, and score with the model in memory.

Answer

Register the model as a spark_udf and wrap it in a Structured Streaming query so each store's records are processed as a separate micro-batch.

Question 14

A data engineer needs to score 40 million records nightly using a scikit-learn model logged with MLflow and registered in Unity Catalog. Each prediction depends only on that row's feature values (no grouping or per-group state), and the input DataFrame is a Spark DataFrame. The team wants the simplest approach that distributes the scoring across the cluster without writing custom grouping logic. Which approach should they use?

Accepted Answer

Load the model as a Spark UDF with mlflow.pyfunc.spark_udf() and apply it to the feature columns in a withColumn call.

Answer

Use df.groupBy().applyInPandas() with a function that loads the model and returns predictions for each group.

Answer

Convert the Spark DataFrame to a pandas DataFrame with toPandas() and call model.predict() on the driver.

Answer

Deploy the model to a Databricks Model Serving endpoint and send each row as a REST request.

Question 15

A data engineering team must score 40 million customer records once every night using a model registered in Unity Catalog. The scoring output feeds a downstream reporting table, and there is no requirement for sub-second per-record latency. The team wants the most efficient and cost-appropriate way to run this workload on Databricks. Which approach should they choose?

Accepted Answer

Load the model as a Spark UDF with mlflow.pyfunc.spark_udf and apply it to the Spark DataFrame in a scheduled batch job

Answer

Deploy the model to a Databricks Model Serving endpoint and send each record via REST calls in a loop

Answer

Configure a Structured Streaming query with a foreachBatch sink that queries a serving endpoint for each micro-batch

Answer

Register the model as a real-time endpoint with scale-to-zero enabled and trigger it from a nightly job

Question 16

A data engineer needs to score incoming IoT sensor readings in near-real-time. Records arrive continuously in a Delta table, and the team wants each new micro-batch to be scored by a model registered in Unity Catalog, with predictions written continuously to an output Delta table. Which approach correctly implements this streaming inference pipeline?

Accepted Answer

Load the model with mlflow.pyfunc.spark_udf(), read the source table with spark.readStream, apply the UDF to add a prediction column, and write results using writeStream with a Delta sink.

Answer

Deploy the model to a Databricks Model Serving endpoint and configure the endpoint to automatically consume the Delta table as a streaming source.

Answer

Load the model with mlflow.pyfunc.load_model() and call model.predict() inside a for-loop that polls the source table every few seconds.

Answer

Read the source table with spark.read (batch), apply the spark_udf, and schedule the notebook to run every minute as a Databricks Job.

Question 17

A data engineering team ingests transaction events into a Delta table that is continuously updated. They want to score each incoming micro-batch of records in near real time using a model that was logged with MLflow and registered in Unity Catalog. They plan to read the Delta table as a streaming DataFrame and apply the model. Which approach correctly enables continuous scoring of the streaming data with the registered model?

Accepted Answer

Load the model as a Spark UDF with mlflow.pyfunc.spark_udf() and apply it to the streaming DataFrame read via spark.readStream, then write results out with writeStream.

Answer

Deploy the model to a Databricks Model Serving endpoint and query it once per hour with a scheduled batch job.

Answer

Load the model with mlflow.pyfunc.load_model() and call model.predict() directly on the streaming DataFrame, then use df.write.save() to persist results.

Answer

Convert the streaming DataFrame to a pandas DataFrame with toPandas() and score it in a loop inside a foreachBatch handler.

More Databricks-ML-Associate practice