Databricks-ML-Pro Flashcards — Free Databricks Certified Machine Learning Professional Study Cards

Implement a custom MLflow PyFunc model where both the text preprocessing and the scikit-learn predictor are encapsulated inside the predict method.

Integrating the preprocessing directly into the MLflow PyFunc wrapper ensures that the input transformation runs within the optimized inference container memory space, avoiding out-of-band network calls and reducing serialization overhead. This architectural pattern prevents latency bottlenecks often introduced by separate preprocessing microservices, satisfying strict production SLAs.

MLflow Model Registry

MLflow Model Registry provides a centralized model store, set of APIs, and UI for managing the full lifecycle of MLflow models. It enables versioning, model stage transitions, and lineage tracking, which are critical for MLOps maturity. By using the Model Registry, teams ensure reproducibility and governance, allowing for seamless promotion of models from staging to production while maintaining an audit trail of changes and deployment history.

TorchDistributor

TorchDistributor is the native Databricks library designed to launch distributed PyTorch training jobs seamlessly across cluster nodes using standard PyTorch native CLI commands and environment configurations. Understanding distributed training orchestration on Databricks is crucial for scaling deep learning pipelines on large datasets without manually managing cluster communication sockets.

Use a Spark-based cross-validator or distribute folds across the cluster.

Leveraging Spark's distributed nature for cross-validation allows you to train folds in parallel, maximizing cluster utilization. By using libraries like Spark MLlib or distributed cross-validation wrappers, you can scale the evaluation process to datasets that would otherwise be impossible to handle on a single node. This ensures robust model evaluation while respecting the operational constraints of large-scale distributed data processing.

A significant drop in model prediction accuracy on production data.

Performance degradation, often caused by model drift or data drift, is the primary driver for retraining. While monitoring system metrics like latency is important, the predictive quality of the model is the ultimate metric. Detecting a significant drop in accuracy or precision indicates that the model is no longer meeting business requirements, triggering the need for a new training cycle in an automated MLOps workflow.

Configure auto-scaling settings in the Model Serving endpoint definition to handle traffic fluctuations.

Databricks Model Serving utilizes auto-scaling compute resources to handle fluctuations in traffic. By configuring the serving endpoint with appropriate auto-scaling parameters, the platform dynamically adjusts the number of concurrent instances based on request load. This ensures that the application maintains low latency under heavy load while remaining cost-effective during periods of low activity, which is essential for managing production-level model inference at scale.

MLflow Model Registry.

The MLflow Model Registry is the definitive tool in Databricks for managing the model lifecycle. It allows teams to register models, track versions, and manage stage transitions (e.g., Staging to Production). By providing a centralized, audit-trailed repository, it ensures that only validated models are deployed into production, fulfilling the core requirements of MLOps for governance, reliability, and automated deployment pipelines.

Log the model with MLflow using the sklearn flavor and a custom pyfunc wrapper that includes the preprocessing steps.

Wrapping preprocessing and the estimator in a single pyfunc model lets MLflow serialize both as one artifact. Batch scoring loads that artifact with the pyfunc loader, and Model Serving uses the same artifact, so feature transformations are guaranteed identical and training-serving skew is avoided without duplicating logic.

It enables centralized lineage tracking between data tables and MLflow models. / Models registered in Unity Catalog can be shared across multiple workspaces.

Unity Catalog acts as the centralized governance layer for all data and AI assets. It provides fine-grained access control and lineage tracking, allowing organizations to maintain visibility over which data is used by which models. By centralizing these assets, teams can collaborate safely while ensuring that compliance and auditing requirements are satisfied across the entire organization, regardless of the individual workspace where the work is performed.

Using Databricks Lakehouse Monitoring to track inference data distributions.

Databricks Lakehouse Monitoring provides automated insights into data quality and drift by comparing production inference data against training baselines. This is essential for detecting the performance decay caused by concept or data drift. By identifying these issues early, teams can trigger automated retraining pipelines, maintaining model accuracy over time and ensuring the business value of the deployed model is sustained.

Check the built-in request metrics and logs for the serving endpoint to analyze duration distribution.

Monitoring tools provided by Databricks, such as the built-in request metrics and logs, are essential for identifying latency bottlenecks. By examining request volume, processing duration, and resource utilization, you can determine if the latency is due to model complexity, infrastructure constraints, or external data dependencies. This allows for data-driven optimization, such as choosing a larger workload size, optimizing the model architecture, or implementing caching for frequently accessed data inputs.

The model artifact created by log_model is stored in the MLflow tracking store's internal directory structure.

MLflow handles artifacts differently based on the log function used. While 'log_artifact' takes a explicit path (often DBFS or local filesystem), 'log_model' packages the model with its metadata and dependencies into a standard MLflow directory structure. Understanding this distinction is essential for production deployments, as model registry and deployment tools rely on the specific internal structure generated by the 'log_model' function, not just raw file paths.

To ensure that the inference environment has the necessary dependencies installed.

These files define the environment specification required to recreate the model's runtime environment. When a model is moved to a production serving endpoint or a different cluster, Databricks uses these specifications to install the correct library versions. This ensures that the model executes in an environment identical to the one it was trained in, preventing silent failures caused by library version mismatches.

Fit your scaler/transformer exclusively on the training portion of the data. / Use Spark ML Pipeline objects to chain preprocessing and model training steps. / Ensure that test data is strictly isolated from the preprocessing pipeline.

Preventing data leakage is essential for valid model performance. The key is to calculate statistics (like means or scaling factors) strictly on the training set and apply them to the validation/test sets. Using Spark ML transformers encapsulates this logic, ensuring that the transformation process is consistent and prevents the model from 'seeing' information from the test set during the training phase, leading to accurate performance estimation.

It enables MLflow to enforce data types during inference, preventing schema mismatch errors.

Providing a model signature and input example defines the expected data schema, allowing MLflow to perform type validation during inference. This is vital for production systems, as it prevents runtime errors caused by malformed inputs and enables Databricks to automatically generate deployment documentation and test payloads, significantly reducing the debugging time when deploying models to Model Serving endpoints.

Using DLT Expectations to define and enforce constraints on input data.

Integrating data quality checks, such as those provided by Delta Live Tables (DLT) expectations or Great Expectations, is crucial for MLOps. By enforcing schema and statistical constraints at the ingest and preparation stages, the pipeline can fail early if data quality falls below standards, preventing the training of 'garbage-in-garbage-out' models and saving compute costs while maintaining model reliability in production.

Write a Python script that evaluates the model and conditionally calls the Model Registry API.

Integrating conditional logic into the retraining script using the MLflow API allows for programmatic model governance. By evaluating the model against validation data and only calling 'register_model' if the performance exceeds the threshold, the team prevents poor-quality models from entering the registry. This automated gatekeeping is vital for maintaining the health of the production pipeline and ensuring that only high-performing models proceed to deployment.

Use SparkTrials to distribute the hyperparameter search across the cluster. / Log hyperparameters and metrics explicitly inside the objective function.

Using SparkTrials allows Hyperopt to distribute trial execution across multiple cluster nodes, significantly accelerating grid or random search. Integrating MLflow within the objective function ensures that each trial's parameters, metrics, and artifacts are captured, enabling users to analyze the tuning history and select the best model based on validated performance metrics.

Include the package in the model's conda.yaml or requirements.txt file when logging the model with MLflow.

Databricks Model Serving builds a container for the model based on the environment specified during MLflow model logging. By including the private PyPI package in the conda.yaml or requirements.txt with the appropriate index URL, the package is installed in the serving environment. This is the supported method for custom dependencies.

It enables consistent, reproducible, and versioned deployment environments.

Model-as-Code treats the entire deployment process—infrastructure, environment configuration, and code—as versioned artifacts. This allows for total reproducibility, where any production state can be rolled back or recreated using stored definitions. This practice is essential for enterprise MLOps, as it ensures that deployments are predictable, scalable, and audit-compliant, significantly reducing the risks associated with manual configuration changes in a production environment.