Databricks-ML-Pro Practice Test 3 — 30 Questions

Question 1

A machine learning engineer is using MLflow Tracking to log metrics and artifacts for a deep learning model. They notice that the training run logs a large number of metrics (e.g., loss per batch) and want to reduce the storage footprint and improve query performance. They also need to retain the ability to compare runs and reproduce results. Which of the following actions is most appropriate?

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

Accepted Answer

Log only the final epoch metrics and use MLflow's step parameter to log intermediate metrics less frequently.. MLflow's log_metric function can accept a step parameter to record metrics over time, but logging every batch creates a large number of entries. Reducing the logging frequency or only logging final epoch metrics significantly decreases storage and improves query speed while still providing enough data for comparison and reproducibility. Other options either lose MLflow's tracking capabilities or introduce unsupported configurations.

Answer

Disable metric logging entirely and rely on TensorBoard for visualization.

Answer

Use a different tracking server with a NoSQL backend to handle the high volume of metrics.

Answer

Store metrics in a separate file and log it as an artifact instead of using mlflow.log_metric.

Question 2

A machine learning engineer is using MLflow to track experiments and has logged a model with a signature. They now want to register this model in the MLflow Model Registry and promote it to Production. Which MLflow API call should they use to add the model to the registry?

Accepted Answer

mlflow.register_model(model_uri, name). The mlflow.register_model function is designed to take an existing model URI and add it as a new version to the Model Registry. It is the standard way to register a model after logging. Other options either create empty models or log new models, which do not fit the scenario of promoting an already logged model.

Answer

mlflow.log_model(model, artifact_path, registered_model_name=name)

Answer

mlflow.pyfunc.save_model(path, loader_module, data_path, registered_model_name=name)

Answer

mlflow.create_registered_model(name)

Question 3

A machine learning team is transitioning from local notebooks to Databricks. They want to ensure their code is modular and reusable. Which THREE practices should they implement?

Accepted Answer

Package common utility code into Python wheels.. Transitioning to Databricks requires moving away from monolithic notebooks toward modular code structures. Using Delta Lake for data consistency, moving logic into Python wheels, and utilizing Repos for version control are the standard industry practices. These steps ensure that code is maintainable, testable, and capable of being integrated into automated CI/CD pipelines, which is the hallmark of mature MLOps practices within a Databricks workspace.

Answer

Keep all training, preprocessing, and evaluation code in a single notebook.

Answer

Hardcode all file paths and credentials in every notebook.

Question 4

When utilizing the Databricks Feature Store for model development, why should a developer define a primary key in the Feature Table?

Accepted Answer

To enable the Feature Store to perform automated lookups for model inference.. Defining a primary key is essential for enabling point-in-time joins during model inference. It allows the Feature Store to perform lookups efficiently and ensures that data consistency is maintained between training and serving. By using primary keys, the system can automatically handle complex join operations, reducing the risk of data leakage and simplifying the feature engineering pipeline for production deployment.

Answer

To increase the write throughput of the Delta table underlying the feature store.

Answer

To bypass the need for performing data validation checks on features.

Answer

To automatically convert all features into a sparse matrix format.

Question 5

A team is building a feature store in Databricks. They need to ensure that training data and inference data are consistent to avoid training-serving skew. What is the primary benefit of using the Databricks Feature Store in this context?

Accepted Answer

It provides a unified interface for computing features, ensuring consistency between training and inference.. The Databricks Feature Store enables the reuse of feature pipelines, ensuring that the exact same transformation logic is applied during both training and inference. By decoupling feature generation from model training, it creates a 'single source of truth' for features, effectively eliminating training-serving skew and improving the reliability of models in production. This is a vital component for maintaining feature consistency across distributed teams.

Answer

It automatically scales the underlying cluster during training runs.

Answer

It forces data scientists to use only Python for feature engineering.

Answer

It eliminates the need for any data cleaning or preprocessing steps.

Question 6

Which action should be taken to ensure that sensitive PII data is not leaked when logging models using MLflow?

Accepted Answer

Ensure data used for model artifacts is scrubbed of PII.. Sanitizing data before logging or excluding sensitive columns from the training set is a security best practice. MLflow logs metadata and often sample data. If PII is included, it is persisted in the artifact store. By ensuring only non-sensitive features are logged, you comply with data privacy regulations and prevent unauthorized access to sensitive information within your model artifacts.

Answer

Encrypt the entire MLflow experiment folder using workspace-level encryption.

Answer

Set the MLflow model registry to 'Private' mode.

Answer

Delete the MLflow run immediately after deployment.

Question 7

You are migrating a legacy ML pipeline to Databricks. You need to ensure that the feature engineering logic used during training is identical to the logic used during real-time inference. What is the recommended approach?

Accepted Answer

Use the Databricks Feature Store to define and log features.. Consistency between training and inference (the 'training-serving skew') is a primary cause of model failure. The Databricks Feature Store acts as the single source of truth for feature definitions. By using it, you ensure that the same transformations are applied during both training and inference, eliminating discrepancies that arise from re-implementing logic in different languages or frameworks, which is critical for model reliability.

Answer

Copy the feature transformation code into both the training notebook and the inference service.

Answer

Store the features in a Parquet file and load it during both training and inference.

Answer

Implement the transformation logic as a SQL view in the Hive Metastore.

Question 8

A machine learning engineer needs to deploy a custom PyTorch model to a Databricks Model Serving endpoint. The model requires a custom pre-processing step that is not part of the standard MLflow transformers or pyfunc flavor. Which deployment approach ensures the custom logic executes reliably within the serverless serving container?

Accepted Answer

Implement a custom MLflow pyfunc PythonModel subclass that encapsulates both the PyTorch model and the custom pre-processing transformations, then log it with MLflow.. Packaging the custom pre-processing logic directly into the MLflow pyfunc model artifact by overriding the predict context ensures that all required transformations travel with the model weights. This guarantees identical execution behavior between local testing and production serverless endpoints without relying on external pipeline code.

Answer

Register the vanilla PyTorch state dict and apply pre-processing transformations inside the client application before sending HTTP payloads.

Answer

Define a separate Spark UDF inside the serving endpoint configuration file to intercept incoming JSON batches.

Answer

Store the pre-processing code in a separate volume and reference its absolute file path in the model serving endpoint environment variables.

Question 9

You are using MLflow to track experiments for a computer vision model. After several runs, you notice that the training loss is not being logged correctly because the metric name contains a space. What is the recommended way to log metrics with names that include spaces?

Accepted Answer

Replace spaces with underscores or hyphens before logging.. MLflow enforces strict naming rules for metrics and parameters, disallowing spaces. The correct approach is to replace spaces with underscores or hyphens before logging. This maintains compatibility with the MLflow tracking server, UI, and API, and avoids logging errors. Other options either do not solve the problem or introduce unnecessary complexity.

Answer

Use the `mlflow.log_metric` function with the space included; MLflow will automatically sanitize it.

Answer

Log the metric as a tag instead of a metric.

Answer

Use a custom MLflow plugin to allow spaces in metric names.

Question 10

Which Databricks feature is specifically designed to prevent data leakage during model training by ensuring feature values are fetched as they existed at a specific point in time?

Accepted Answer

Databricks Feature Store.. Point-in-time joins are the core mechanism of the Databricks Feature Store. When training on historical data, it is critical to use features that were available at that time, not their current values. This prevents 'look-ahead bias,' where future information inadvertently leaks into the training set, causing the model to perform artificially well during training but failing in production.

Answer

Delta Lake Time Travel.

Answer

MLflow Model Registry.

Answer

Auto Loader.

Question 11

Your team is migrating models to Databricks Model Registry. You need to ensure that production models are only deployed after passing specific validation tests. Which feature best facilitates this automated governance?

Accepted Answer

Configuring Model Registry webhooks for status transitions.. Model Registry webhooks are the critical component for automating governance. By triggering external CI/CD pipelines (like Jenkins or GitHub Actions) upon model version transitions (e.g., 'Pending' to 'Production'), organizations enforce quality gates. This ensures that only models validated by automated unit tests or performance benchmarks are promoted, reducing manual intervention and minimizing the risk of deploying underperforming models into production environments.

Answer

Using MLflow Experiments to log model artifacts.

Answer

Hard-coding model versions in inference notebooks.

Answer

Executing manual SQL queries against the MLflow backend.

Question 12

In an automated MLOps workflow, what is the best practice for handling model training failures?

Accepted Answer

Logging the error and triggering an automated notification.. Failing fast and sending alerts is the standard practice. Automated pipelines should include error handling that logs the failure cause to MLflow and triggers a notification via email or Slack. This ensures that data scientists can address the issue immediately without waiting for a manual audit of the pipeline, maintaining the overall health and reliability of the automated machine learning lifecycle.

Answer

Retrying the training job indefinitely.

Answer

Ignoring the error and deploying the previous model.

Answer

Deleting the failed experiment run.

Question 13

A data scientist is training a deep learning model on Databricks. They observe that the training process is significantly slower than expected. Upon inspection, they find that data loading from DBFS is the bottleneck. What is the most effective way to improve data loading speed for deep learning training on Databricks?

Accepted Answer

Use the Petastorm library to read data directly from Delta tables.. Using Petastorm or the standard 'tf.data' dataset API with Delta Lake significantly improves throughput for deep learning models. By converting data into a highly efficient, partitioned format that can be streamed directly to GPU memory, developers bypass the latency overhead associated with reading small files from DBFS, enabling the model to utilize the full processing power of the allocated cluster.

Answer

Move all data to local disk on the driver node.

Answer

Convert the dataset into a single large CSV file.

Answer

Increase the learning rate to reduce training time.

Question 14

Your team uses Databricks Model Serving to host a production model. You need to ensure zero-downtime updates while maintaining the ability to revert to the previous version instantly if performance degrades. Which deployment strategy should you implement?

Accepted Answer

Use a Blue-Green deployment strategy with traffic splitting.. Blue-green deployment allows you to maintain a production endpoint while simultaneously deploying a new version. By using weighted traffic splitting, you can shift traffic gradually and monitor performance metrics. If the new version exhibits anomalies, you can instantly revert traffic to the stable version, ensuring high availability and minimizing the impact of potential production failures, which is critical for robust MLOps workflows.

Answer

Directly update the existing model serving endpoint to the new version.

Answer

Delete the current serving endpoint and create a new one with the updated model.

Answer

Increase the instance count of the existing endpoint before updating.

Question 15

A data scientist is iterating on a model and notices that their training runs are becoming disorganized. What is the standard Databricks mechanism for tracking different 'attempts' at model improvement within a single project?

Accepted Answer

Grouping runs within an experiment and using MLflow tags.. MLflow tracking allows for multiple 'runs' under a single experiment. Each run captures parameters, metrics, and artifacts. By systematically naming or tagging these runs, the data scientist can easily compare performance metrics (like RMSE or F1-score) in the MLflow UI. This structured approach is fundamental to scientific experimentation and prevents the loss of valuable insights when iterating on model architectures or hyperparameter sets.

Answer

Using a new Git branch for every single hyperparameter change.

Answer

Writing the results to a shared CSV file in the root directory.

Answer

Storing all run parameters in the notebook's global variable state.

Question 16

A data scientist needs to perform batch inference on a large dataset stored in Delta Lake using a model registered in the Unity Catalog. Which approach is most efficient for leveraging Spark's distributed computing capabilities while using the MLflow model?

Accepted Answer

Using mlflow.pyfunc.spark_udf to wrap the model and applying it to the Spark DataFrame columns.. MLflow provides a built-in function to load models as Spark User Defined Functions (UDFs). This allows the model to be distributed across the executor nodes of a Spark cluster, enabling parallel processing of large datasets. This method is preferred over manual iteration as it integrates seamlessly with the Spark DataFrame API and optimizes resource utilization during high-volume batch jobs.

Answer

Loading the model with mlflow.pyfunc.load_model and using a for-loop to iterate over DataFrame rows.

Answer

Converting the Delta table to a Pandas DataFrame and using the standard model.predict() method.

Answer

Calling the Model Serving REST API for every row in the Delta Lake table using a standard Python request.

Question 17

Which statement best describes the role of the 'Signature' in an MLflow model when deploying to a Databricks Model Serving endpoint?

Accepted Answer

It specifies the data types and names of the input features and the output predictions.. An MLflow Model Signature defines the schema of the inputs and outputs for a model. This is crucial for Model Serving as it allows the endpoint to perform input validation before the data reaches the model. It also enables the UI to generate a 'Call' template, making it easier for developers to test the API.

Answer

It is a cryptographic hash used to verify the integrity of the model files.

Answer

It lists the specific users and groups who have permission to call the endpoint.

Answer

It contains the hyperparameters used during the final training run of the model version.

Question 18

When evaluating a classification model on Databricks, a team needs to generate a custom performance report that is not natively provided by MLflow. What is the recommended strategy to ensure this report is persisted and associated with the training run?

Accepted Answer

Save the report to a local temporary file and use MLflow.log_artifact to upload it to the run.. Logging custom plots and reports as artifacts is the recommended way to enrich MLflow run metadata. By saving visualizations or summary statistics as files (e.g., HTML, PNG, or JSON) and using 'log_artifact', the team ensures that non-standard evaluation metrics are permanently stored. This practice allows stakeholders to review specific model performance indicators without needing to re-run the training code, which is vital for compliance and post-training analysis.

Answer

Print the report to the notebook output and rely on the notebook's command history.

Answer

Store the report in an external database and manually link it via a comment in the run.

Answer

Re-generate the report every time the model is loaded for inference.

Question 19

A machine learning engineer is training a PyTorch model on a Databricks cluster and needs to distribute the training across multiple worker nodes. Which framework should be integrated natively within Databricks to handle this distributed deep learning workflow efficiently?

Accepted Answer

TorchDistributor. TorchDistributor is the native Databricks library designed to launch distributed PyTorch training jobs seamlessly across cluster nodes using standard PyTorch native CLI commands and environment configurations. Understanding distributed training orchestration on Databricks is crucial for scaling deep learning pipelines on large datasets without manually managing cluster communication sockets.

Answer

Databricks Feature Store Client

Answer

MLflow Model Registry

Answer

Spark MLlib Pipeline

Question 20

A machine learning engineer wants to ensure that model training artifacts are persistent and accessible even if the ephemeral compute cluster is terminated. What is the standard practice in Databricks for achieving this?

Accepted Answer

Log the model using MLflow, which stores the artifact in the configured backend.. In Databricks, local cluster storage is ephemeral and is deleted when the cluster terminates. To ensure model artifacts persist, developers must log them to MLflow, which automatically handles the backend storage in DBFS or Unity Catalog-managed storage. This practice decouples the model lifecycle from the compute lifecycle, ensuring that models remain available for deployment or further evaluation after the compute resources are released.

Answer

Save the model to the local file system using the /dbfs/ path prefix.

Answer

Export the model artifact to a temporary workspace file and download it locally.

Answer

Configure the cluster to use an external persistent volume for local storage.