Free Practice Questions for Databricks Databricks-Machine-Learning-Professional Exam

The log_metric function is used to log a numeric metric value to the current MLflow run. It takes the name of the metric and the value as arguments. In this case, the name of the metric is “rmse” and the value is the variable rmse. The log_metric function can be used multiple times to log different metrics or update the same metric. The log_artifact function is used to log a file or directory as an artifact to the current MLflow run. The log_model function is used to log a model with a specified flavor to the current MLflow run. The log_param function is used to log a key-value pair as a parameter to the current MLflow run. There is a way to store values like this using the log_metric function, so option E is incorrect.https://docs.databricks.com/

To enable MLflow Autologging for all supported machine learning libraries in a notebook, you can use the mlflow.autolog() function. This function enables autologging for each library by invoking the corresponding autologging function, such as mlflow.sklearn.autolog() or mlflow.spark.autolog(). This way, you do not need to call each autologging function separately. The mlflow.autolog() function also takes care of the compatibility and configuration issues that may arise from different versions of the Databricks Runtime for Machine Learning or workspace-wide settings in the Admin Console. The other options are incorrect because:

Option A: mlflow.sklearn.autolog() will only enable autologging for scikit-learn, not for other libraries.

Option B: mlflow.spark.autolog() will only enable autologging for Spark MLlib, not for other libraries.

Option C: spark.conf.set(“autologging”, True) is not a valid way to enable autologging, as there is no such configuration option in Spark.

Option D: It is possible to automatically log MLflow runs using the autologging functions provided by MLflow. References: Automatic Logging with MLflow Tracking, MLflow quickstart (Python)

MLflow Model flavors are a key concept that makes MLflow Models powerful: they are a convention that deployment tools can use to understand the model, which makes it possible to write tools that work with models from any ML library without having to integrate each tool with each library. MLflow defines a set of built-in model flavors for popular ML frameworks, such as scikit-learn, TensorFlow, PyTorch, etc. Each flavor defines a standard format for model data and a common interface for model inference. For example, the python_function flavor allows any model to be loaded as a Pythonfunction that can be applied to input data. MLflow also supports custom model flavors for user-defined models or community-developed flavors. MLflow Model flavors enable model portability and interoperability across different platforms and environments12 References:

MLflow Models — MLflow 2.9.1 documentation

Models, Flavors, and PyFuncs in MLflow

A model signature is a specification of the input and output schema of a model, which defines the names, data types, and shapes of the model inputs and outputs. Logging a model signature with an MLflow model has several benefits, such as:

The signature can be used to document what type of data is expected as input and output by the model, which can help users and developers understand how to use the model correctly.

The signature can be used to enforce schema validation when serving models via REST API, which can help prevent errors and ensure data quality. For example, Azure Machine Learning enforces compliance with the model signature for MLflow models that contain a signature1.

The signature can be used to enable automatic conversion of input data to the appropriate format for the model, such as pandas DataFrame, numpy array, or PyTorch tensor. This can simplify the data preprocessing and inference steps and reduce the code complexity.

References:

MLflow Models Documentation, Model Signature and Input Example, p. 6-7

mlflow.models.signature Documentation, p. 1-2

Guidelines for deploying MLflow models - Azure Machine Learning, p. 1

MLflow Autologging is a feature that automatically logs parameters, metrics, and artifacts for machine learning frameworks, such as Hyperopt, without requiring any code changes. When using MLflow Autologging with Hyperopt, MLflow will automatically create a parent run for the hyperparameter tuning process and a child run for each unique combination of hyperparameter values. This way, the user can easily compare and visualize the results of different hyperparameter settings in the MLflow UI. MLflow Autologging also supports nested runs, which means that if the user starts a manual run before calling fmin, the parent run will be nested under the manual run. This allows the user to organize and group related runs together. References: MLflow Autologging, Hyperparameter Tuning with MLflow, Apache Spark MLlib and Hyperopt, Using MLFlow with Hyperopt for Automated Machine Learning, Parallelize hyperparameter tuning with scikit-learn and MLflow, [Optimizing Model Performance with MLflow and Hyperopt: From Hyperparameter Tuning to Serving]

The client.delete_registered_model method of the MlflowClient class can be used to delete a model from the MLflow Model Registry. The method takes the following parameter:

name: The name of the registered model to delete.

The method deletes the registered model and all its versions from the Model Registry. The method does not return any value1

The other options are incorrect because:

A. The client.transition_model_version_stage method can be used to transition a model version to a different stage, such as None, Staging, Production, or Archived. The method does not delete the model or the model version from the Model Registry2

B. The client.delete_model_version method can be used to delete a specific model version from the Model Registry. The method does not delete the registered model or all its versions from the Model Registry3

C. The client.update_registered_model method can be used to update the metadata of a registered model, such as its name or description. The method does not delete the model or its versions from the Model Registry4

D. There is no method called client.delete_model. To delete a model from the Model Registry, the client.delete_registered_model method should be used.

References:

mlflow.tracking.client.MlflowClient.delete_registered_model — MLflow 2.9.1 documentation

mlflow.tracking.client.MlflowClient.transition_model_version_stage — MLflow 2.9.1 documentation

mlflow.tracking.client.MlflowClient.delete_model_version — MLflow 2.9.1 documentation

mlflow.tracking.client.MlflowClient.update_registered_model — MLflow 2.9.1 documentation

Z-Ordering is an optimization technique that can speed up the query by colocating similar records while considering values in multiple columns. Z-Ordering is a way of organizing data in storage based on the values of one or more columns. Z-Ordering maps multidimensional data to one dimension while preserving locality of the data points. This means that rows with similar values for the specified columns are stored close together in the same set of files. This improves the performance of queries that filter on those columns, as they can skip over irrelevant files or data blocks. Z-Ordering also enhances data skipping and caching, as it reduces the number of distinct values per file for the chosen columns1. The other options are incorrect because:

Option B: Bin-packing is an optimization technique that compacts small files into larger ones, but does not colocate similar records based on multiple columns. Bin-packing can improve the performance of queries by reducing the number of files that need to be read, but it does not affect the data layout within the files2.

Option C: Writing as a Parquet file is not an optimization technique, but a file format choice. Parquet is a columnar storage format that supports efficient compression and encoding schemes. Parquet can improve the performance of queries by reducing the storage footprint and the amount of data transferred, but it does not colocate similar records based on multiple columns3.

Option D: Data skipping is an optimization technique that skips over files or data blocks that do not match the query predicates, but does not colocate similar records based on multiple columns. Data skipping can improve the performance of queries by avoiding unnecessary data scans, but it depends on the data layout and the metadata collected for each file4.

Option E: Tuning the file size is an optimization technique that adjusts the size of the data files to a target value, but does not colocate similar records based on multiple columns. Tuning the file size can improve the performance of queries by balancing the trade-off between parallelism and overhead, but it does not affectthe data layout within the files5. References: Z-Ordering (multi-dimensional clustering), Compaction (bin-packing), Parquet, Data skipping, Tuning file sizes

The correct line of code is “MODEL_VERSION_TRANSITIONED_STAGE”, which is the name of the event that occurs when a model version transitions to any stage in the MLflow Model Registry. This event can be used to trigger a webhook that will execute a Databricks Job based on the model version and the stage it transitions to. The other options are either invalid event names or too specific for the task.

References: MLflow Model Registry Webhooks, MLflow Model Registry Events