Databricks Certified Machine Learning Professional

The Databricks Certified Machine Learning Professional validates advanced expertise in operationalizing machine learning models at scale using the Databricks platform. It focuses on model deployment, monitoring, and the automation of ML lifecycles to ensure high performance in production. Achieving the symbol DTB_MLP marks a professional as an expert in managing the end-to-end machine learning process for enterprise applications.

---------- Question 1

A large e-commerce company processes terabytes of customer transaction data daily to train a personalized recommendation model. The dataset contains millions of unique products and billions of interactions. They want to use the Databricks platform to build a scalable ML pipeline for this task. Data scientists have experimented with a single-node Gradient Boosted Trees model which performs well but takes too long to train on the full dataset. They need to distribute the training and tune hyperparameters efficiently. Which approach is most appropriate for building a scalable ML pipeline and performing distributed hyperparameter tuning for this scenario on Databricks?

1. Train multiple single-node Scikit-learn models using Databricks Koalas for data handling and manually run a grid search across a cluster of instances.
2. Utilize SparkMLs Pipeline API with a SparkML Estimator such as GBTClassifier and implement distributed hyperparameter tuning using CrossValidator coupled with ParamGridBuilder.
3. Convert the dataset to a pandas DataFrame, then use the pandas Function API to distribute the training of a single-node LightGBM model across worker nodes and perform hyperparameter tuning with a custom loop.
4. Use a single-node deep learning framework like PyTorch on a large single machine with a GPU, then manually scale up the machine as the dataset grows and perform manual hyperparameter tuning.

---------- Question 2

A large financial institution needs to develop a fraud detection model. The data resides in Delta Lake, with billions of transactions. Features are pre-computed daily and stored in Databricks Feature Store. The data science team wants to build a scalable model training pipeline that leverages SparkML for feature engineering, model training, and evaluation. After training, the best model should be registered in MLflow Model Registry, and the entire process should be tracked. They also need to ensure that the features used for training are retrieved consistently from the Feature Store, avoiding data leakage. Which combination of Databricks capabilities and practices would best fulfill these requirements?

1. Use pandas UDFs for feature engineering, train a scikit-learn model on a single node, then log the model manually to MLflow.
2. Construct a SparkML pipeline using FeatureEngineeringClient to load features, apply SparkML transformers for additional processing, train a SparkML estimator, and log the entire pipeline as an MLflow model, ensuring point-in-time correctness.
3. Extract all data into a local CSV, perform feature engineering with Pandas, train a LightGBM model, and then serve it using custom Flask application.
4. Use a Pandas DataFrame for all data manipulation and model training, then serialize the model object to DBFS for storage.

---------- Question 3

A large social media platform is planning to deploy a new content recommendation model. They need a deployment strategy that minimizes risk, allows for testing the new model with a small user segment before a full rollout, and enables quick rollback to the previous version if any issues are detected. The platform handles extremely high traffic, and downtime is unacceptable. Which deployment strategy and Databricks Model Serving capabilities are most suitable for this scenario?

1. Directly replace the old model with the new one on the existing serving endpoint and monitor for errors post-deployment.
2. Implement a blue-green deployment strategy using Databricks Model Serving, deploying the new model to a separate endpoint, and then switching traffic instantly after validation.
3. Utilize a canary deployment strategy with Databricks Model Serving, gradually routing a small percentage of production traffic to the new model, monitoring its performance, and then incrementally increasing traffic or rolling back as needed.
4. Deploy the new model manually to a new endpoint, disable the old endpoint, and then manually update all client applications to point to the new endpoint.

---------- Question 4

An Internet of Things IoT analytics firm collects and processes telemetry data from millions of diverse industrial sensors. Their objective is to develop personalized anomaly detection models for each distinct group of sensors, as each group exhibits unique operational patterns. Training a single, global model is demonstrably ineffective for detecting specific group anomalies, and training individual models sequentially for hundreds of thousands of groups would consume an unacceptably long time. The training algorithm for each individual group is computationally modest but needs to be applied independently to a large number of partitioned datasets. What is the most efficient and scalable approach on Databricks to train these independent anomaly detection models for such a vast number of distinct device groups, ensuring optimal resource utilization and timely model delivery?

1. Implement a single-node Python script that iterates through each group, trains a model, and saves it sequentially, running this script on a Databricks job cluster.
2. Use the Spark pandas Function API with groupByKey to parallelize the training process, where a custom Python function trains an anomaly detection model for each group within a distributed Spark DataFrame.
3. Convert all group data into a single large CSV file, then load it into a deep learning framework like PyTorch on a single GPU cluster, training a meta-learning model.
4. Manually provision separate Databricks clusters for each major device group, running independent training jobs simultaneously, and managing each cluster individually.

---------- Question 5

A specialized healthcare AI startup has developed a novel diagnostic model that integrates complex image pre-processing with a custom deep learning inference engine. This model requires several proprietary Python libraries not typically included in standard MLflow environments and also performs a unique post-processing step on its predictions before returning a final diagnosis. The team needs to deploy this custom model as a real-time API endpoint using Databricks Model Serving, ensuring all dependencies and custom logic are correctly packaged and served. How should they approach registering and deploying this custom PyFunc model?

1. Register the deep learning model directly as a standard MLflow flavor without including custom pre/post-processing logic or proprietary libraries.
2. Containerize the entire application as a custom Docker image and deploy it separately, bypassing Databricks Model Serving altogether.
3. Create a custom PyFunc model, wrapping the image pre-processor, deep learning engine, and post-processor within the PyFuncs predict method. Ensure all proprietary libraries are specified in the conda environment or requirements file, log the PyFunc model and its custom artifacts to Unity Catalog, and deploy it via Databricks Model Serving.
4. Use a generic PyFunc wrapper that only includes the deep learning inference, performing pre/post-processing outside the serving endpoint.

---------- Question 6

A healthcare startup is developing a deep learning model for early disease detection from medical images. The training dataset is extremely large, residing in cloud object storage, and the model architecture is complex, requiring significant computational resources. The team wants to optimize hyperparameters efficiently across a cluster of GPU-enabled machines. They need to track each trial's performance, resource utilization (e.g., GPU memory, CPU usage), and specific custom metrics (e.g., F1-score for different disease classes) within a structured experiment. Which approach ensures scalable hyperparameter tuning with comprehensive tracking and allows for easy comparison of different trial configurations?

1. Manually run multiple training scripts with different hyperparameters on separate clusters, then compare results from individual MLflow runs.
2. Implement a grid search manually using nested loops in Python, training each model sequentially on a single machine, logging to MLflow.
3. Utilize Optuna integrated with MLflow, performing distributed hyperparameter tuning on a Databricks cluster. Log custom metrics and system metrics for each Optuna trial as nested MLflow runs to track granular details.
4. Train a simple model without hyperparameter tuning, relying on default parameters for faster development, then scale inference only.

---------- Question 7

A bio-tech startup has developed a novel drug discovery model using a highly customized ensemble of proprietary algorithms implemented in Python, not directly compatible with standard ML frameworks like scikit-learn or TensorFlow. They need to deploy this model as a real-time API endpoint on Databricks to serve predictions to their researchers for drug compound screening. It is crucial that all model dependencies and supporting files are securely managed, versioned, and easily retrievable within their data governance framework, which utilizes Unity Catalog. How should they package, register, and deploy this custom model on Databricks?

1. Convert the custom model into a generic ONNX format and deploy it as a standard MLflow model.
2. Deploy the Python code directly as a Databricks Job and schedule it to run batch predictions periodically.
3. Package the custom model as an MLflow PyFunc model, log it to Unity Catalog with all its custom artifacts and dependencies, and then deploy it using Databricks Model Serving via the MLflow Deployments SDK or UI.
4. Host the custom model on an external cloud function service and manually integrate it with Databricks.

---------- Question 8

An energy company has developed a highly specialized predictive maintenance model. This model incorporates proprietary C++ simulation libraries for structural analysis, which are wrapped in Python using ctypes, alongside a deep learning component built with TensorFlow. The entire custom inference logic, including data pre-processing specific to sensor inputs and post-processing of predictions, is encapsulated within a custom Python class. They need to deploy this complex model on Databricks Model Serving to provide real-time predictions via a REST API. The model and its dependencies must be properly packaged and served. How should this custom model be registered and deployed on Databricks Model Serving?

1. Register the TensorFlow model directly as an MLflow flavor, and manage the C++ library and custom pre/post-processing separately outside MLflow.
2. Wrap the entire custom inference logic, including the TensorFlow model and C++ library wrappers, within an MLflow PyFunc model, log it to Unity Catalog with all necessary dependencies, and deploy it via Databricks Model Serving.
3. Create a custom Docker container with the model and all dependencies, and deploy it to a Kubernetes cluster managed externally from Databricks Model Serving.
4. Break down the custom model into multiple microservices: one for C++ simulation, one for TensorFlow inference, and one for pre/post-processing, then orchestrate them with a custom API gateway.

---------- Question 9

A financial institution is building a fraud detection system using a Databricks Lakehouse architecture with a Delta Lake Feature Store. One critical feature, transaction_velocity_30d, calculates the average transaction amount over the last 30 days for each customer. During model training, the team needs to ensure that historical feature values are aligned with historical labels to prevent data leakage. The model will be trained using SparkML. When inferring in production, real-time features need to be fetched for new transactions, combining historical and on-demand computations efficiently. Which combination of Databricks Feature Store capabilities and design principles ensures point-in-time correctness for transaction_velocity_30d during training and consistent retrieval for real-time inference?

1. Registering transaction_velocity_30d as a batch feature table with a primary key and timestamp key, then using the FeatureEngineeringClient to create a training dataset and configuring an online table for real-time serving.
2. Storing transaction_velocity_30d as a streaming feature table using Structured Streaming, ensuring data is always fresh, and directly joining with labels for training.
3. Developing transaction_velocity_30d as an on-demand feature, calculating it during both training and inference using a UDF, without storing it in a feature table.
4. Using a simple SQL join on the raw data at training time with a window function for transaction_velocity_30d, and implementing a separate lookup service for real-time inference.

---------- Question 10

A data science team is training a complex deep learning model for image classification on a massive dataset using Databricks. They want to find the optimal set of hyperparameters efficiently. Given the large number of trials and the computational intensity of each trial, they need a distributed hyperparameter tuning solution that can scale across multiple nodes and leverage the elasticity of the cloud. They are also keen on tracking all trials and their performance within MLflow. Which approach effectively integrates distributed hyperparameter tuning with MLflow on Databricks for this scenario?

1. Manually configuring a Grid Search on a single Spark driver node, logging each trial as a separate MLflow run.
2. Implementing a distributed hyperparameter tuning process using Optuna integrated with MLflow, leveraging Spark workers for parallel trials.
3. Using a simple for loop to iterate through hyperparameter combinations on a single machine, saving the best model.
4. Performing distributed training using SparkMLs CrossValidator with a limited parameter grid.

---

Are they useful?

Click here to get 360 more questions to pass this certification at the first try! Explanation for each answer is included!

Follow the below LINKEDIN channel to stay updated about 89+ exams!

Digital Intelligence Network