Databricks Certified Machine Learning Professional (Databricks-ML-Pro) — Questions 76–150

mlflow.register_model is the correct API to register an existing model artifact from a run into the Model Registry. It takes the model URI (e.g., runs:/<run_id>/model) and the desired model name. This call creates a new model version in the registry, which can then be transitioned to Production.

Registry webhooks can trigger on MODEL_VERSION_CREATED events, invoking a Databricks job that runs validation and then updates the serving endpoint via the REST API. This provides an event-driven, automated pipeline that meets the requirement of updating upon registration and successful validation.

Providing a signature when logging the model with `mlflow.pyfunc.log_model` captures the expected input and output schema. This signature is used during inference to validate that the input data matches the expected schema, helping to prevent errors and ensuring consistency. It is the standard way to enable schema enforcement in MLflow.

Inheriting from PythonModel provides a standardized way to define custom predict methods. This ensures that the model can be loaded by any client with the pyfunc flavor, regardless of the underlying library used for training, fulfilling the requirement for environment-agnostic deployment in Databricks.

Delta tables are optimized for high-performance reading and writing in Databricks. They support the versioning and time-travel features required by Feature Store, which ensures that training sets can be recreated precisely, promoting model reproducibility and enabling seamless integration with the broader Databricks ML ecosystem.

In Databricks, you can install libraries at the cluster level, making them available to all notebooks and jobs that run on that cluster. For a job, you can define a job cluster with the required library installed. This ensures the library is present for every run without manual installation, and it isolates the library to that cluster, preventing impact on other jobs. This is the recommended and simplest approach for job-specific dependencies.

The Feature Store automatically handles point-in-time joins using specified lookup keys and timestamps. This functionality is essential for preventing data leakage during training, as it ensures that the training dataset only contains information that would have been available at the moment of prediction in a real-world setting.

`mlflow.log_metric` is the correct API to log a custom metric manually. It must be called within an active MLflow run, typically started with `mlflow.start_run()`. This ensures the metric is associated with that specific run. This approach is standard for logging metrics not captured by autologging, such as custom evaluation scores or business-specific KPIs.

Logs are the primary source of truth for runtime failures. They will contain stack traces if the model code crashed, memory exhaustion errors, or connectivity issues with external services. Reviewing logs is the fastest way to determine if the issue is environmental or logic-based.

Pinning dependencies ensures that the environment is consistent across runs, preventing issues caused by library updates. This is critical for reproducibility in ML pipelines, where even minor version changes can affect model training and inference. Using a requirements file or conda environment specification allows the pipeline to recreate the exact environment.

Inference tables are a Databricks Model Serving feature that captures request and response payloads to a Delta table automatically. This provides the exact logging needed for monitoring and retraining without modifying the model code or building custom logging infrastructure.

Calling mlflow.sklearn.autolog() before fit() hooks into scikit-learn's training APIs, capturing hyperparameters, metrics, and the fitted model artifact automatically, with no manual logging calls. This directly satisfies the stem's requirement to avoid extensive boilerplate logging code during Databricks training runs.

MLflow allows you to log custom code along with the model by including it in the model's artifacts and specifying it in the model's Python function or by using the `code_path` parameter in `mlflow.pyfunc.log_model`. This ensures the custom transformer is available at inference time. Databricks Model Serving will then load the code from the model artifact, making it the correct and straightforward solution.

MLflow automatically captures Git metadata, including the commit hash, repository URL, and branch, when the code is executed from within a Git repository. In Databricks, if the notebook is part of a Git folder (Repos), MLflow will log the Git commit hash as a tag on the run. This is an automatic feature and requires no additional configuration beyond being in a Git repo. This is the correct way to capture source code version.

Model Serving is the dedicated service for hosting models. It manages the server infrastructure, auto-scaling, and deployment of models from the registry. This allows data science teams to deploy models via a single click or API call, ensuring consistent, scalable production performance without manual configuration of servers.

The 'transition_model_version_stage' method is the standard programmatic way to manage lifecycle transitions in Databricks. By embedding this in the pipeline, the system verifies test results first, then immediately updates the stage, ensuring that only validated models are marked as ready for further staging or production deployment.

Databricks Model Serving supports traffic splitting, allowing you to route a percentage of requests to different model versions within the same endpoint. By specifying the traffic percentage for each served entity, you can gradually shift traffic from the old to the new version. This enables safe rollout and performance monitoring without disrupting the endpoint.

Providing a requirements file or Conda environment during logging tells MLflow exactly which packages and versions are needed. When the model is deployed to an endpoint, Databricks uses this information to build a container image with all the necessary dependencies pre-installed and ready for execution.

By utilizing a centralized Metastore, Unity Catalog allows models to be registered once and accessed by authorized users across any workspace linked to that Metastore. This facilitates better collaboration and standardization across large organizations that use separate environments for development, testing, and production stages.

The signature provides a contract for the model, detailing the expected data types and shapes. The serving infrastructure uses this contract to validate every API request, catching mismatches before they reach the model code. This prevents crashes and provides clear error messages when invalid data is submitted.

Training on a subset for hyperparameter search reduces the time per trial, allowing more configurations to be explored quickly. After identifying the best hyperparameters, retraining on the full dataset recovers full model quality. This is a common and effective strategy when the dataset is large and individual trials are slow, as it balances search efficiency with final performance.

Subclassing `mlflow.pyfunc.PythonModel` allows encapsulating custom pre-processing and the scikit-learn pipeline. The `predict` method can call the pipeline and any additional logic. Logging with `mlflow.pyfunc.log_model` saves the model with its dependencies, enabling serving with the full pipeline. This is the standard approach for custom models.

Databricks Jobs provide scheduling, cluster specification, and notification configuration in one place. A notebook task can read the Delta table, retrain, and register the model. Schedule triggers and failure notifications are built-in, directly meeting all stated requirements without external orchestration tools.

Databricks SQL dashboards can query inference tables to compute statistics and compare them against baseline distributions. This allows you to visualize drift and set up alerts. By leveraging SQL, you can create scheduled queries that detect significant deviations and trigger notifications, providing an effective monitoring solution without additional infrastructure.

Time travel allows the model training job to reference an immutable snapshot of the Delta table. This ensures that the dataset used for training remains exactly the same, even if new data is appended or existing rows are updated, providing the necessary stability for reliable, reproducible machine learning experiments.

Databricks Model Serving supports serving multiple model versions on a single endpoint with configurable traffic splits. This enables canary deployments where a small percentage of traffic goes to the new version, allowing gradual rollout and rollback if issues arise. This is the native and recommended strategy for safe updates.

Databricks Repos allows teams to manage code using Git, which is essential for CI/CD. Synchronizing code across environments ensures that the exact same logic tested in staging is deployed in production, minimizing the risk of 'it works on my machine' errors and facilitating smooth, reproducible deployments.

The Databricks Secrets API allows developers to store sensitive information securely within Databricks and retrieve it programmatically. This keeps credentials out of the codebase entirely, ensuring that only users with the appropriate permissions can access them and that secrets are never logged or stored in version control systems.

Staging acts as a testing sandbox where teams can run integration tests or shadow deployments against live data. This ensures that the model is fully vetted for stability and performance in a controlled environment similar to production, mitigating the risk of issues when the model goes live.

Configuring scaling units correctly allows Databricks Model Serving to automatically scale compute resources up during traffic surges and scale down to zero during idle periods. This balance prevents latency degradation under heavy load while minimizing unnecessary cloud expenditure when request volumes drop.

Using 'mlflow.start_run()' within a context manager ensures that all tracking information is cleaned up correctly, even if the code fails. 'mlflow.autolog()' reduces boilerplate code by capturing common model parameters and metrics automatically, significantly improving the consistency and efficiency of the experiment tracking process across the organization.

Feature Specs allow for consistent, reusable feature transformations. By defining the logic in the Feature Store, the team ensures the same preprocessing code is used for both training and online serving. This standardizes the pipeline, reduces engineering effort, and prevents training-serving skew, ensuring that models perform consistently in production.

Stages and aliases provide an indirection pointer to a specific model version. By promoting only through a controlled step, the scoring job always resolves to the exact version that was validated, and retraining that registers new versions does not alter production until an explicit promotion changes the pointer, satisfying immutability and traceability.

Transitioning to 'Production' and having jobs reference the stage ensures that when a new version is promoted, the jobs automatically pick it up. This is the intended workflow for stage-based model deployment in MLflow Model Registry, enabling seamless updates without code changes.

Databricks Model Serving integrates directly with Unity Catalog and MLflow. You create an endpoint via the Serving UI or the REST API, specifying the full model name and version. The service automatically provisions the necessary infrastructure and builds a container with the model's dependencies, making this the standard and supported deployment path.

Lakehouse Monitoring automates the process of comparing current inference data distributions against training data snapshots. It identifies statistically significant drift, providing the necessary visibility for proactive model maintenance. This tool is standard for maintaining model performance in production, ensuring that decay is detected and addressed promptly.

The MLflow UI's Runs table displays runs with columns for parameters, metrics, and tags. Users can sort by a metric column and apply filters to narrow down runs. This is the standard way to compare runs and find the one with the lowest RMSE. It provides a quick visual comparison.

The `mlflow.pyfunc` flavor allows packaging any Python model with custom preprocessing and prediction logic. By subclassing `PythonModel` and implementing `predict`, the data scientist can include preprocessing steps directly in the model artifact. This ensures the entire logic is self-contained and reproducible during serving. It is the most flexible flavor for custom code.

Inference tables automatically capture request and response data from a Model Serving endpoint and store them in a Delta table. This enables monitoring of prediction drift, data quality, and model performance by analyzing the logged data. It is the native Databricks feature designed for this purpose, integrating with Lakehouse Monitoring.

Automating validation via notebooks allows for programmatic assertion of metrics like accuracy or latency. This creates a reliable quality gate that runs as part of the deployment pipeline. If the model fails the assertions, the pipeline halts, preventing the promotion of a sub-par model to production.

The 'best trial' notebook contains all the preprocessing and training code that produced the top-performing model. By cloning this notebook, the data scientist gains full control over the feature engineering pipeline, allowing them to iterate on transformations and custom logic that AutoML initially discovered or implemented automatically.

Setting a minimum provisioned concurrency ensures that a specified number of model instances are always running, ready to handle requests. This eliminates cold-start latency during traffic spikes, as instances are pre-loaded with the model. For a model with a large memory footprint and slow load time, this is crucial to avoid downtime and maintain performance.

Automation is at the heart of MLOps. By scripting the model registry interactions within CI/CD pipelines, engineers ensure that models move through stages consistently, preventing manual errors and ensuring that the promotion process is documented and repeatable across the organization's different deployment environments.

The Feature Store allows you to create feature tables with versioning and lineage. When you train a model using features from the Feature Store and log the model with mlflow.pyfunc.log_model, it automatically records the feature lookup keys and the feature table versions. This creates a direct link between the model and the features used, satisfying audit requirements for feature lineage.

The built-in monitoring tools provide granular data on request duration and system performance. Analyzing this distribution allows you to identify if the latency is systematic or limited to specific types of requests, enabling you to pinpoint if the bottleneck lies in compute resources, model execution, or network overhead.

Without a signature, MLflow lacks a formal description of the model's expected input and output types. This can cause problems when deploying to Model Serving or when using the model in a batch scoring job that expects schema validation. The model artifact itself is still usable, but the missing schema may lead to integration issues or ambiguous behavior.

The 'log_artifact' method is the standard way to attach any file, including custom reports, images, or plots, to an MLflow run. This provides a robust and centralized way to keep evaluation results alongside the model, enabling comprehensive documentation of the model lifecycle directly within the Databricks MLflow tracking environment.

Stage transitions in MLflow Model Registry are governed by model-level permissions. A service principal running the pipeline needs at least CAN_MANAGE_PRODUCTION or CAN_MANAGE to move a version into Production. Without this grant, the API call to transition the stage will fail with a permission error, making the pipeline non-repeatable. This is a required, concrete step for automated promotion.

When logging a scikit-learn model with `mlflow.sklearn.log_model`, MLflow automatically includes the `python_function` flavor. This makes the model loadable via `mlflow.pyfunc.load_model`, which provides a generic interface for inference. The Python function flavor wraps the native model, allowing it to be used in environments where the original library may not be available or for consistent serving.

Asynchronous logging decouples the logging operation from the inference path. The model returns predictions immediately, and logging occurs in the background. This significantly reduces latency because the response is not delayed by I/O operations. Databricks Model Serving supports asynchronous logging via custom code or by using the inference table feature, which logs asynchronously.

The 'log_model' function creates a standardized structure containing the model binary, a MLmodel file, and a conda.yaml file. This allows MLflow to maintain environment parity during deployment. The tracking store automatically manages these artifacts, abstracting the underlying storage layer, which ensures consistency across different stages of the ML lifecycle.

Recording descriptions and tags on stage transitions provides an audit trail linking each promotion to a specific pipeline run and approver. This supports governance by making it possible to trace who or what promoted a model and why, which is essential for compliance and incident investigation.

DMM is the native solution for monitoring production models. It automates drift detection, schema validation, and performance tracking, providing ready-made dashboards and alerts. It eliminates the need to build custom monitoring infrastructure, making it the most efficient choice for teams wanting to maintain high-quality models in production.

Specifying `pip_requirements` captures the exact library versions needed to recreate the training environment. MLflow stores this in the model's conda and requirements metadata, so a later restore recreates the same dependency set. This is how the team achieves a reproducible environment rather than relying on whatever happens to be installed on the scoring cluster.

Databricks implements model-specific permissions. To register or modify model versions, the user must have the appropriate permission level assigned to that specific model object. This follows standard security best practices by limiting access to authorized users without granting excessive, unnecessary privileges across the entire workspace or environment.

The `pip_requirements` parameter allows you to specify a list of pip requirements, which MLflow will use to create a `requirements.txt` file. This is an alternative to Conda and is particularly useful in environments where Conda is not available. It ensures that the serving environment installs the correct packages, though it may not capture non-Python dependencies as comprehensively as Conda.

Defining a feature computation function with the Feature Store client and registering it ensures that the same logic is used for training and scoring. Creating a Feature Store table with a scheduled refresh automatically updates features. This approach provides consistency, versioning, and lineage. It directly satisfies the need for identical feature computation and automatic refresh, making it the correct solution for the engineer's pipeline.

Databricks Model Serving provides a fully managed, serverless solution to deploy models as REST API endpoints with automatic scaling based on traffic. It integrates with Unity Catalog for model governance and supports real-time inference. This is the standard feature for deploying models for real-time serving in Databricks, offering built-in monitoring and scaling without managing infrastructure.

Fitting on only the training data ensures that the model does not incorporate information from the validation or test sets. This is the most effective way to prevent data leakage during preprocessing, ensuring that the model's evaluation metrics are realistic and reflect its actual performance on unseen, future production data.

Automated tests on a holdout dataset verify that the model meets performance thresholds before promotion. Comparing against a baseline ensures that the new model does not regress. This step is essential for safe automation, as it gates deployment on objective criteria and prevents degradation in production.

Scale-to-zero is designed to save costs by scaling down to zero replicas when there is no traffic. When a request arrives after idle time, the endpoint must scale up, causing a cold start and increased latency for that request. This is a fundamental trade-off between cost and latency.

Scikit-learn models must be trained via the .fit() method before they contain the internal state necessary for inference. Logging an unfitted instance saves an empty shell, which cannot perform predictions. The model must be trained on representative data to ensure the internal weights are populated correctly.

Inference tables capture the payloads sent to and returned from a Model Serving endpoint and persist them to a Unity Catalog Delta table. This gives an auditable record of the model inputs for drift analysis and links each request to the served model version, satisfying both traceability and auditability requirements without custom logging code.

The online store is a separate materialized copy optimized for low-latency lookup, and it does not automatically inherit schema changes made to the offline Delta table. Publishing again refreshes the online table to include the new columns so the serving lookup matches what the model expects. Redeploying ensures the model signature aligns with the updated feature schema.

The conda.yaml file is part of the MLflow model artifact and specifies the environment dependencies, including Python packages from PyPI. When deploying to Databricks Model Serving, the serving infrastructure uses this file to build the environment. Therefore, the engineer should add the library and its version to the pip section of conda.yaml.

DLT Expectations provide a declarative way to define data quality rules. By automatically monitoring data against these rules and failing the pipeline or isolating bad records, engineers ensure that only high-quality data enters the training set, which is essential for building reliable, production-grade machine learning systems.

The model signature acts as a contract between the model and the caller. If the provided input does not match the signature's types, the model serving endpoint will reject the request with a clear error, ensuring that the inference engine receives the exact data format the model expects.

Databricks Model Serving supports inference logging, which automatically captures request and response payloads and writes them to a specified Delta table. This can be enabled in the endpoint configuration without changing the model code. It is the intended feature for auditing and monitoring, and requires only setting the logging destination.

When scale-to-zero is enabled, the endpoint scales down to zero replicas after inactivity. The first request after idle time triggers a scale-up, causing the request to be queued until a replica is available. This results in higher latency for that initial request. Subsequent requests are served with normal latency.

Databricks Model Serving provides built-in metrics such as request count, latency, and error rates, which are displayed in the endpoint's detail page in the Databricks UI. These metrics are available without additional configuration and can be used to monitor the health and performance of the endpoint.

Databricks Model Serving supports serving multiple model versions within a single endpoint by specifying a traffic split percentage for each version. This allows canary deployments where a small portion of traffic goes to the new version while the majority remains on the stable version. It is the recommended approach for testing new versions with live traffic.

Databricks recommends using aliases such as 'champion' or 'Production' to mark the version that serving endpoints and jobs should consume. Assigning the alias to the validated version promotes it without mutating the version itself, and endpoints configured to serve that alias pick up the change.

Wrapping the model in a custom PyFunc that computes SHAP values at inference time allows explanations to be generated for each request. While this adds latency, it can be optimized by using efficient SHAP implementations and limiting the number of background samples. This approach provides real-time explanations and can be deployed to Model Serving. It meets the requirement for per-prediction explainability and auditability, though latency must be managed.

Gold tables provide clean, validated data that matches business requirements. This makes them the ideal source for training models. By building models on Gold data, scientists ensure that their features are based on reliable information, significantly reducing the probability of errors caused by poor data quality in production pipelines.

mlflow.search_runs() allows you to query runs across experiments using a SQL-like filter and returns a pandas DataFrame containing metrics, parameters, and tags for all matching runs. This makes it easy to programmatically compare metrics across runs, sort them, and perform further analysis. It is the most efficient way to retrieve and compare multiple runs in MLflow.