Databricks-Machine-Learning-Professional Sample Questions Answers

Structured Streaming is a scalable and fault-tolerant stream processing engine built on the Spark SQL engine. It allows users to express streaming computations the same way as batch computations on static data, using DataFrame and Dataset APIs. Structured Streaming can handle both unbounded and bounded data sources, and can process data in micro-batches or continuously. Structured Streaming can be used to provide continuous processing of data for machine learning applications, such as data ingestion, preprocessing, feature engineering, and model inference. StructuredStreaming can also integrate with MLflow and Delta Lake to enable end-to-end machine learning pipelines with tracking, reproducibility, and governance123 References:

• Structured Streaming Programming Guide - Spark 3.2.0 Documentation
• Structured Streaming + Kafka Integration Guide (Kafka broker version 0.10.0 or higher) - Spark 3.2.0 Documentation
• Machine Learning with Structured Streaming - Databricks
• [Continuous Machine Learning with Structured Streaming and MLflow - Databricks]

To view all of the active MLflow Model Registry Webhooks for a specific model, the machine learning engineer needs to replace POST with GET in the call to http request. This is because the HTTP method for listing webhooks is GET, not POST. The GET method is used to retrieve information from the server, while the POST method is used to send data to the server1. The syntax of the http request function is as follows:

Python

http_request(host_creds, endpoint, method, json=None, headers=None)

AI-generated code. Review and use carefully. More info on FAQ.

The other options are incorrect because:

• Option A: There are no necessary changes is incorrect, as the code block will not work with the POST method.
• Option B: Replace list with view in the endpoint URL is incorrect, as the endpoint URL for listing webhooks is “/api/2.0/mlflow/registry/webhooks/list?model_name=model”, not “/api/2.0/mlflow/registry/webhooks/view?model_name=model”. There is no view endpoint for webhooks2.
• Option D: Replace list with webhooks in the endpoint URL is incorrect, as the endpoint URL for listing webhooks is “/api/2.0/mlflow/registry/webhooks/list?model_name=model”, not “/api/2.0/mlflow/registry/webhooks/webhooks?model_name=model”. The list keyword is required to specify the list operation2.
• Option E: Replace POST with PUT in the call to http request is incorrect, as the HTTP method for listing webhooks is GET, not PUT. The PUT method is used to update data on the server, not to retrieve information1. References: HTTP request methods, List webhooks

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

A pyfunc model is a generic Python model that can be loaded and used to make predictions using any Python ML library. By logging a custom model class that implements the preprocessing logic as a pyfunc model, the same logic will be applied when loading the model and calling the predict method on new data. This ensures consistency and reproducibility of the model predictions. The fit method is not relevant for loading a logged model, as it is only used for training the model. The pyfunc model does not affect the parallelizability or the need for pipeline-like objects of the model deployment. References: mlflow.pyfunc, Creating custom Pyfunc models

MLflow provides a utility function mlflow.models.signature.infer_signature that can infer the input schema and the output schema of a model from a sample dataset. The input schema and the output schema are represented as mlflow.types.schema.Schema objects, which define the names, data types, and shapes of the model inputs and outputs. The infer_signature function can be used for any model that implements a predict method that takes a pandas DataFrame or a numpy array as input and returns a pandas DataFrame, a pandas Series, a numpy array, or a list as output. The infer_signature function can also be used for models that implement a transform method that takes a pandas DataFrame as input and returns a pandas DataFrame as output. The infer_signature function can be used before logging the model with MLflow, as it does not require the model to be in MLflow format or registered with MLflow Model Registry. References:

• MLflow Models Documentation, Model Signature and Input Example, p. 6-7
• mlflow.types.schema Documentation, p. 1-2
• Machine Learning Engineering with MLflow, Managing Model Signatures and Schemas, p. 1

The context parameter is an instance of mlflow.pyfunc.model.ModelContext, which is a wrapper around the model metadata and artifacts. The context parameter allows the user to provide the model access to objects like preprocessing models or custom configuration files that are needed for the model inference. For example, the context parameter can be used to load a scikit-learn preprocessing model that was logged as an artifact with the MLflow model, and then apply it to the input data before passing it to the main model. The context parameter can also be used to access the model signature and the input example, if they were logged with the model. The context parameter is passed to the load_context and predict methods of the PythonModel class, which is asubclass of mlflow.pyfunc.PythonModel that defines the custom logic for loading and scoring the model. References:

• mlflow.pyfunc Documentation, p. 1-2
• mlflow.pyfunc.model Documentation, p. 1-2
• Understanding PyFunc in MLflow, Part 2: Pyfunc Components, p. 1-2
• python - How to load model from mlflow with custom predict without local file?, p. 1-2

To create nested runs in MLflow, you need to specify the nested=True argument in the parent run, and omit it in the child runs. This will set a special tag (mlflow.utils.mlflow_tags.MLFLOW_PARENT_RUN_ID) in the child runs that indicates the parent run ID. This way, the UI will show the child runs under the parent run in a collapsible hierarchy. The indentation of the code blocks is not relevant, as long as the child runs are created within the context of the parent run. The run name parameter is also not relevant, as it does not affect the nesting of the runs. References: Understanding Parent and Child Runs in MLflow, Nested runs using MLflowClient, creating-child-runs-in-mlflow

To replace all data in a feature table with newly computed data, you can use the fs.write_table method with the mode argument set to “overwrite”. This will overwrite the existing data in the feature table with the data in the provided DataFrame. The other options are incorrect because:

• Option A: fs.create_table will create a new feature table, not replace the data in an existing one. If the feature table already exists, it will raise an exception.
• Option B: fs.write_table without specifying the mode argument will use the default mode of “merge”, which will merge the new data with the existing data, not replace it.
• Option C: fs.write table is not a valid method name, as it is missing an underscore. Also, the mode argument of “merge” will not replace the data, but merge it with the existing data.
• Option E: fs.create_table with the mode argument of “merge” is not a valid combination, as the mode argument is only applicable for fs.write_table. Also, the mode argument of “merge” will not replace the data, but merge it with the existing data. References: Databricks FeatureStoreClient, Work with features in Workspace Feature Store

MLflow provides a module called mlflow.pyfunc that can be used to deploy any Python model as a PySpark UDF. The mlflow.pyfunc.spark_udf function takes a Spark session and a model URI, and returns a Spark UDF that can be applied to a Spark DataFrame. The model URI can be a local path, a remote path, or a run ID with a relative path within the MLflow tracking server. The mlflow.pyfunc.spark_udf function can be used with any model that has a predict function, such as scikit-learn, xgboost, etc12

The other code blocks are incorrect because:

• A. The mlflow.pyfunc.spark_udf function requires a Spark session as the first argument, not a Spark DataFrame.
• B. It is possible to deploy a scikit-learn model on a Spark DataFrame using mlflow.pyfunc.spark_udf or other methods, such as broadcasting the model or using Fugue.
• C. There is no module called sklearn.spark_udf. To use a scikit-learn model as a Spark UDF, mlflow.pyfunc.spark_udf or other methods should be used.
• D. There is no method called spark.spark_udf. To create a Spark UDF, the spark.udf.register or pyspark.sql.functions.udf methods should be used.

References:

• mlflow.pyfunc — MLflow 2.9.1 documentation
• Deploy models for batch inference and prediction - Databricks

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

Real-time deployment is a paradigm that can centrally compute predictions for a single record with exceedingly fast results. Real-time deployment involves exposing a model as a REST API endpoint that can receive requests and return predictions in milliseconds. This paradigm is suitable for scenarios where low latency and high throughput are required, such as fraud detection, recommendation systems, or chatbots. The other deployment paradigms are not as fast or as centralized as real-time deployment. Streaming deployment involves processing data streams in micro-batches, which can introduce some delay. Batch deployment involves processing large batches of data at scheduled intervals, which can take hours or days. Edge or on-device deployment involves deploying models to edge devices, such as mobile phones or IoT sensors, which can reduce the network overhead but also limit the computational power and model size. https://docs.databricks.com/en/machine-learning/ml-tutorials.html

Batch serving is a type of model deployment where predictions are computed in advance and stored for later use. This can be useful when the feature values are known ahead of time and the predictions need to be delivered quickly. Querying stored predictions can be faster than computing predictions in real-time, especially if the model is complex or the data volume is high. Real-time serving is a type of model deployment where predictions are computed on-demand at query time. This can be useful when the feature values are not known in advance or the predictions need to be up-to-date. However, computing predictions in real-time can be slower than querying stored predictions, especially if the model is simple or the data volume is low. References: [Batch Serving], [Real-time Serving] Message has links.

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

To drop a column from a Delta table, you need to enable column mapping mode for the table and use the ALTER TABLE statement with the DROP COLUMN clause. Alternatively, you can use the spark.read.format(“delta”).table(path) method to read the Delta table as a DataFrame and then use the drop method to drop the column. This will return a new DataFrame with the column removed. You can then overwrite the originalDelta table with the new DataFrame using the write.format(“delta”).mode(“overwrite”) method. The other options are incorrect because:

• Option A: spark.read.format(“delta”).load(path) will not read the Delta table as a table, but as a directory of files. This will not preserve the schema and metadata of the table, and will not allow you to overwrite the table with the new DataFrame.
• Option C: Delta tables can be modified using the Delta Lake APIs or SQL commands. Delta Lake supports schema evolution and column mapping to enable dropping columns from Delta tables.
• Option D: spark.read.table(path) will not work for Delta tables, as it expects a table name, not a path. To read a Delta table by its path, you need to use the spark.read.format(“delta”).load(path) or spark.read.format(“delta”).table(path) methods.
• Option E: spark.sql(“SELECT * EXCEPT star_rating FROM path”) will not drop the column from the Delta table, but only return a new DataFrame with the column excluded. This will not affect the original Delta table, and will not allow you to overwrite the table with the new DataFrame. References: Drop columns, Delta Lake Quickstart, Delta Lake column mapping

Concept drift in machine learning and data mining refers to the change in the relationships between input and output data in the underlying problem over time. In other domains, this change maybe called “covariate shift,” “dataset shift,” or “nonstationarity.” Concept drift can affect the performance and accuracy of predictive models that assume a static relationship between input and output variables. Concept drift can be caused by various factors, such as changes in user behavior, environmental conditions, market trends, etc. Concept drift can be detected and handled by various methods, such as periodic retraining, online learning, ensemble methods, etc References:

• Concept drift - Wikipedia
• A Gentle Introduction to Concept Drift in Machine Learning
• Model Drift & Machine Learning: Concept Drift, Feature Drift, Etc.
• Data Drift vs. Concept Drift: What Is the Difference?