Databricks-ML-Assoc Model Development — Timed 40 Questions

Question 1

A data scientist is training a Random Forest model on a 500GB dataset using Databricks. They notice that the model training process is crashing due to OutOfMemory (OOM) errors on the driver node. Which approach should be taken to resolve this?

40 minute time limit — choose an answer to begin.

Accepted Answer

Use Spark MLlib's RandomForestRegressor instead of scikit-learn.. Random Forest models often store the entire trained forest in memory. When the forest is large, the driver node—which aggregates the model object from executors—runs out of memory. Moving to a distributed training approach or sampling the data to reduce the forest's complexity are standard ways to prevent this. Proper memory management ensures that model training pipelines remain robust when scaling beyond single-node prototypes to large production datasets.

Answer

Increase the number of executors in the cluster.

Answer

Use the sample() method on the DataFrame before training.

Answer

Enable dynamic allocation on the Spark cluster.

Question 2

Refer to the exhibit. A data scientist needs to programmatically retrieve the model object created by the run identified in the exhibit. Which method call is the correct way to load the model artifact?

Accepted Answer

mlflow.pyfunc.load_model('runs:/d7a8b9c0e1f2/model'). To retrieve a model, the scientist must use the MLflow `pyfunc` interface, which provides a standard way to load models regardless of the specific library used to train them. By providing the URI pointing to the artifacts, the code ensures compatibility across different environments. This is a critical skill for building automated inference pipelines that need to load the latest models based on run IDs stored in databases.

Answer

mlflow.sklearn.load_model('dbfs:/databricks/mlflow/789/d7a8b9c0e1f2/artifacts/model')

Answer

mlflow.load_model('d7a8b9c0e1f2')

Answer

pd.read_pickle('dbfs:/databricks/mlflow/789/d7a8b9c0e1f2/artifacts/model')

Question 3

A data scientist is preparing a custom model for deployment. Which THREE of the following steps are required to ensure the model correctly handles inference requests using the MLflow `pyfunc` flavor?

Accepted Answer

Subclass mlflow.pyfunc.PythonModel.. Creating a custom `pyfunc` model requires wrapping the logic into a class that implements the `predict` method. The model must also be saved with an environment configuration to ensure dependencies are met. Finally, the input signature must be defined so that the model can perform validation on incoming requests. These steps ensure the model is robust, production-ready, and behaves consistently regardless of the deployment environment chosen by the infrastructure team.

Answer

Store the model as a raw serialized joblib object.

Answer

Ensure the model is written in Scala for performance.

Question 4

Which THREE of the following are necessary components for the MLflow Model Registry to manage the lifecycle of a model effectively?

Accepted Answer

Model Versioning.. The Model Registry requires specific components to manage models from experimentation to production. Versioning allows for tracking changes over time; model stages (staging, production, archived) manage the deployment lifecycle; and model aliases provide a way to target specific versions dynamically. These components collectively ensure that organizations can promote models to production with confidence, maintain version history, and easily roll back if performance degrades after deployment.

Answer

Manual file copying to production folders.

Answer

Direct database connection strings in notebooks.

Question 5

A data scientist is training a model on a large dataset and wants to ensure that the training is fault-tolerant. What is the benefit of using the `mlflow.spark.autolog()` feature?

Accepted Answer

It captures model metadata and artifacts without manual log calls.. Autologging simplifies the training process by automatically recording parameters and metrics from supported frameworks. When using Spark, it also captures the model context correctly, making it more robust against cluster restarts or transient failures during long-running training jobs. This feature reduces the amount of boilerplate code, ensuring that data scientists consistently capture essential model metadata without relying on manual and potentially error-prone tracking steps for every single experiment run.

Answer

It automatically scales the cluster based on workload.

Answer

It converts the training data into a Delta table.

Answer

It ensures the model is encrypted on disk.

Question 6

Refer to the exhibit. A data scientist receives this error while trying to register a model in the Model Registry. What is the most likely cause?

Accepted Answer

The model name argument was passed as None.. The `mlflow.register_model()` function or the `log_model()` call with a registered model name requires a non-null string for the name. This error often occurs when the model name variable is not defined or is passed incorrectly in the configuration dictionary. This is a common hurdle during the transition from experimentation to production-grade model registration within the Databricks Model Registry workflow.

Answer

The cluster is running out of memory.

Answer

The user does not have write access to the registry.

Answer

The model artifact is corrupted.

Question 7

When evaluating a classification model in Databricks, why is it preferred to use MLflow to log evaluation metrics like precision and recall rather than manual logging?

Accepted Answer

MLflow automatically creates plots and tracks metric history across runs.. MLflow provides a centralized and versioned repository for all metrics, which enables automated tracking, visualization, and comparison of model runs. Manual logging is prone to errors, lacks versioning, and makes it difficult to compare different experiments. By automating metric logging, data scientists can easily identify which model version performed best across different configurations, ensuring that only the highest-quality models are promoted to production environments.

Answer

Manual logging requires higher compute power on the driver node.

Answer

MLflow prevents the model from being deployed if metrics are low.

Answer

Manual logging causes the Spark cluster to disconnect prematurely.

Question 8

A data scientist is preparing a model for deployment in Unity Catalog. Which TWO steps are required to ensure the model is ready for staging?

Accepted Answer

Ensure the model has an associated signature and input example.. Moving a model to staging requires both the registration of the model in the catalog and the inclusion of a model signature, which defines the schema of inputs and outputs. These steps ensure that downstream inference services can validate incoming data against the expected format, preventing runtime errors and ensuring that the model is fully documented and discoverable within the Databricks ecosystem.

Answer

Manually copy the model code into a Git repository to ensure version control.

Answer

Create a new Model object in Unity Catalog and log the model using the mlflow.models.set_model() function.

Answer

Convert the model to a PMML format to ensure cross-platform compatibility.

Question 9

Refer to the exhibit. A developer encounters this error while trying to register a model in Unity Catalog. How should the developer modify their training code?

Accepted Answer

Use mlflow.models.infer_signature to capture the schema of the training data and predictions, then pass this to log_model.. The error explicitly states that a model signature is required. By generating a signature using the input and output data samples, the developer ensures that the model can be validated against incoming request schemas. This is a best practice for model governance and quality control, ensuring that the model remains robust and predictable when deployed to inference endpoints where data formats are strictly enforced.

Answer

Increase the timeout parameter in the mlflow.log_model call.

Answer

Ignore the error and use the force=True flag in the register_model command.

Answer

Manually create a JSON file containing the signature and upload it to the same path as the model artifacts.

Question 10

Which THREE features are provided by MLflow Model Registry within Databricks?

Accepted Answer

Model versioning and lineage tracking.. MLflow Model Registry offers comprehensive lifecycle management including versioning, status transitions (e.g., Staging to Production), and artifact storage. These features ensure that teams can collaborate effectively, maintain a clear audit trail of model changes, and safely promote models through development environments. By centralizing these tasks, organizations reduce deployment risks and improve the consistency of machine learning operations across different teams and projects.

Answer

Automatic deployment to cloud provider endpoints.

Answer

Automated data cleaning and preprocessing.

Question 11

Which THREE practices are recommended for managing dependencies in Databricks model development?

Accepted Answer

Use the %pip magic command to install required libraries within the notebook.. Managing dependencies is essential for reproducible deployments. Using specific library versions, environment files, and avoiding custom globally installed libraries ensures the training and inference environments remain consistent. Databricks' integration with MLflow allows for automatic capture of these configurations, which helps in preventing runtime issues that commonly occur when library versions mismatch between the development notebook and the production serving environment.

Answer

Manually update the cluster-wide system libraries via init scripts.

Answer

Assume all standard libraries are pre-installed on the Databricks Runtime.

Question 12

When building a multi-stage ML pipeline on Databricks, what is the best practice for capturing intermediate data results for debugging purposes?

Accepted Answer

Log intermediate data as an artifact using mlflow.log_artifact().. Logging intermediate results as artifacts in MLflow is the best practice for debugging and auditability. By treating these intermediate states as artifacts, they remain linked to the experiment, providing a clear history of how the data was transformed at each stage. This is superior to creating temporary tables, which can clutter the workspace and lead to confusion about which data corresponds to which model version.

Answer

Save intermediate data to a shared temporary directory in DBFS.

Answer

Print the intermediate results to the notebook output.

Answer

Store results in a local SQLite database on the driver node.

Question 13

A data scientist is training a model using MLflow on Databricks. They need to ensure that the model environment, including all library dependencies, is captured during the logging process to ensure reproducibility across different clusters. Which approach is most effective for this requirement?

Accepted Answer

Use the log_model function and include a dictionary of installed libraries via the pip_requirements parameter.. Capturing dependencies is critical for model portability. By using the 'pip_requirements' or 'conda_env' parameter during the log_model call, MLflow records a snapshot of the environment. This ensures that when the model is loaded in a production environment, the exact versions of the libraries used during training are restored, preventing runtime errors caused by version mismatches or missing packages in the inference cluster.

Answer

Manually create a requirements.txt file and upload it to the model registry alongside the model artifacts.

Answer

Capture the cluster's current spark_config and save it as an MLflow tag for documentation purposes.

Answer

Rely on the default environment logging, which automatically detects all installed libraries on the driver node.

Question 14

Refer to the exhibit. An engineer is inspecting the MLmodel configuration file for a deployed artifact. Which observation can be correctly drawn from this configuration?

Accepted Answer

The model environment is strictly pinned to specific versions of scikit-learn and pandas.. The exhibit shows a standard MLflow MLmodel metadata structure. The inclusion of 'pip_requirements' is a deliberate design choice that prevents environment drift. This configuration is critical for the MLflow model loader to know exactly which Python version and package versions are required, ensuring that the model runs in a consistent environment. This prevents 'dependency hell' when moving models between development and production environments.

Answer

The model is currently deployed to a real-time endpoint using the MLflow Model Serving service.

Answer

The model is optimized to run on Spark executors because it uses the scikit-learn framework.

Answer

The model was trained using a distributed training library, given the inclusion of Python metadata.

Question 15

When logging a custom model with MLflow in Databricks, the model requires a helper file that is not part of the standard Python library. How should this external dependency be handled to ensure the model loads correctly in a production environment?

Accepted Answer

Pass the path to the helper file in the 'artifacts' parameter of the log_model function.. Custom models require careful handling of external dependencies. Including local files in the 'artifacts' parameter ensures that they are bundled with the model. When the model is loaded, MLflow makes these files available in the working directory. This approach is essential for modular codebases where helper functions or configuration files reside outside the primary model class file.

Answer

Hardcode the path to the file as an absolute path in the training script.

Answer

Upload the helper file to an S3 bucket and use a URL for the model to fetch during initialization.

Answer

Include the helper file in the root directory of the Databricks cluster where the model is deployed.

Question 16

A data scientist is building a custom model that uses a pre-trained external library. Which THREE requirements are essential for correctly packaging this model using the MLflow 'pyfunc' flavor?

Accepted Answer

The custom model must be defined as a class inheriting from mlflow.pyfunc.PythonModel.. Packaging a custom pyfunc model requires a class that inherits from 'PythonModel'. This class must implement the 'predict' method, which is the entry point for inference. Furthermore, the external library must be specified in the environment configuration, and all necessary artifacts (like model weights or configuration files) must be passed to the log_model function to ensure the code has access to these dependencies during execution.

Answer

The predict method must be defined as a static method to avoid serialization issues.

Answer

The custom model must be serialized using pickle.dump before logging to the model registry.

Question 17

A machine learning engineer needs to log a model that was trained outside of Databricks but needs to be managed within the Databricks Model Registry. What is the recommended workflow to achieve this?

Accepted Answer

Log the model using mlflow.pyfunc.log_model, providing the path to the external artifacts.. The recommended approach is to use the MLflow log_model function locally or within a notebook, pointing to the external model files. By explicitly defining the model flavor and providing the required environment metadata, the model is registered as a first-class artifact. This centralizes the model lifecycle management, enabling versioning, staging, and deployment tracking within Databricks, even if the actual training compute was off-platform.

Answer

Manually copy the files into the Databricks DBFS and link them to a Model Registry entry via the UI.

Answer

Upload the model to Unity Catalog as a generic file and point to the location in the notebook.

Answer

Convert the model to a Spark DataFrame and store it as a Delta table in the Hive Metastore.

Question 18

A data scientist is using Databricks to train a model and wants to ensure that the model is automatically registered to the Model Registry if it meets specific accuracy thresholds. How should this be configured?

Accepted Answer

Use the 'registered_model_name' parameter within the log_model function.. The Model Registry provides a programmatic interface for managing model versions. By using the MLflow 'register_model_name' parameter in log_model, you can automate the registration process. This allows teams to create CI/CD pipelines where models are automatically evaluated against metrics, and only those that perform well are promoted to the registry, reducing manual effort and ensuring consistent quality in model deployment pipelines.

Answer

Update the Model Registry manually via the Databricks UI after the run is completed.

Answer

Create a separate job in Databricks Workflows that scans the experiment and registers models.

Answer

Enable the 'Auto-Register' setting in the Databricks cluster configuration.

Question 19

A team is developing a machine learning pipeline where multiple data scientists contribute to the same experiment. What is the most effective way to organize these runs?

Accepted Answer

Create separate MLflow experiments for each developer or logical model task.. Using unique experiment names is crucial for preventing data collisions. When multiple developers work on a project, they should either use distinct experiments or leverage the 'run_name' parameter within a shared experiment to identify their specific contributions. This ensures that metrics and artifacts are properly attributed, allowing for clear comparisons and preventing one user from accidentally overwriting or cluttering the results of another user.

Answer

Share a single experiment name and use tags to identify the developer.

Answer

Use the default experiment, but manually delete unsuccessful runs to keep it clean.

Answer

Require all team members to use the same run name for consistency.

Question 20

A data scientist is working in a notebook and notices that their MLflow tracking logs are not appearing in the expected experiment. What is the most likely cause?

Accepted Answer

The mlflow.set_experiment() function was not called with the correct path.. In Databricks, if the experiment context is not explicitly set, MLflow defaults to a specific path or the notebook-linked experiment. If the scientist is working in a workspace where multiple experiments exist, or if they accidentally used a different experiment name in a previous cell, the tracking will go to the wrong location. Checking the current experiment ID is essential for ensuring that logs are captured in the correct, organized location.

Answer

The cluster is running in 'Single User' mode, which disables MLflow logging.

Answer

The notebook has not been attached to a Unity Catalog-enabled compute resource.

Answer

The MLflow tracking server is down for the entire Databricks workspace.