Model Deployment

Master Databricks Model Serving, batch inference, real-time endpoints, and Model Registry lifecycle management — covering approximately 30% of the exam (Model Lifecycle Management domain).

MLflow Model Registry

The Model Registry is a centralized model store that provides model versioning, stage transitions, and approval workflows. It is the bridge between experimentation and production.

Model Registry Concepts

• Registered Model — A named model in the registry (e.g., "churn-predictor")
• Model Version — A specific version of a registered model, linked to an MLflow run
• Stages — Lifecycle stages: None, Staging, Production, Archived
• Aliases — Named references to specific versions (e.g., "champion", "challenger") — the newer approach replacing stages
• Tags — Key-value metadata on models and versions for organization

Registering a Model

import mlflow

# Method 1: Register during logging
with mlflow.start_run():
    mlflow.sklearn.log_model(
        model,
        "model",
        registered_model_name="churn-predictor"
    )

# Method 2: Register an existing run's model
result = mlflow.register_model(
    model_uri=f"runs:/{run_id}/model",
    name="churn-predictor"
)
print(f"Version: {result.version}")

Stage Transitions

from mlflow.tracking import MlflowClient

client = MlflowClient()

# Transition a model version to Production
client.transition_model_version_stage(
    name="churn-predictor",
    version=3,
    stage="Production",
    archive_existing_versions=True  # archives current Production version
)

Loading Models from Registry

# Load by stage (legacy)
model = mlflow.pyfunc.load_model("models:/churn-predictor/Production")

# Load by alias (recommended)
model = mlflow.pyfunc.load_model("models:/churn-predictor@champion")

# Load by version number
model = mlflow.pyfunc.load_model("models:/churn-predictor/3")

Databricks Model Serving

Model Serving provides managed, real-time REST API endpoints for MLflow models. It handles auto-scaling, load balancing, and infrastructure management.

Creating a Serving Endpoint

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import (
    EndpointCoreConfigInput,
    ServedEntityInput
)

w = WorkspaceClient()

# Create endpoint with a single served model
w.serving_endpoints.create(
    name="churn-predictor-endpoint",
    config=EndpointCoreConfigInput(
        served_entities=[
            ServedEntityInput(
                entity_name="churn-predictor",
                entity_version="3",
                workload_size="Small",
                scale_to_zero_enabled=True
            )
        ]
    )
)

Querying the Endpoint

import requests
import json

# Score a single record
url = "https://<workspace-url>/serving-endpoints/churn-predictor-endpoint/invocations"
headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}

data = {
    "dataframe_records": [
        {"total_purchases": 15, "avg_session_duration": 320, "days_since_last_visit": 7}
    ]
}

response = requests.post(url, headers=headers, json=data)
predictions = response.json()

Traffic Splitting (A/B Testing)

You can route traffic between multiple model versions for A/B testing:

config = EndpointCoreConfigInput(
    served_entities=[
        ServedEntityInput(
            name="champion",
            entity_name="churn-predictor",
            entity_version="3",
            workload_size="Small",
            scale_to_zero_enabled=False
        ),
        ServedEntityInput(
            name="challenger",
            entity_name="churn-predictor",
            entity_version="4",
            workload_size="Small",
            scale_to_zero_enabled=False
        )
    ],
    traffic_config=TrafficConfig(
        routes=[
            Route(served_model_name="champion", traffic_percentage=90),
            Route(served_model_name="challenger", traffic_percentage=10)
        ]
    )
)

Batch Inference

For scoring large datasets, batch inference is more cost-effective than real-time serving:

Using MLflow pyfunc with Spark

import mlflow

# Load model as a Spark UDF
predict_udf = mlflow.pyfunc.spark_udf(
    spark,
    model_uri="models:/churn-predictor@champion"
)

# Apply to a Spark DataFrame
predictions_df = input_df.withColumn(
    "prediction",
    predict_udf("total_purchases", "avg_session_duration", "days_since_last_visit")
)

# Write predictions to Delta table
predictions_df.write.format("delta").mode("overwrite").saveAsTable("predictions.churn_scores")

Feature Store Batch Scoring

from databricks.feature_store import FeatureStoreClient

fs = FeatureStoreClient()

# Score with automatic feature lookup
predictions = fs.score_batch(
    model_uri="models:/churn-predictor@champion",
    df=new_customers_df  # only needs primary key columns
)
# Feature Store automatically joins the required features

Model Monitoring

After deployment, monitor model performance to detect drift and degradation:

• Databricks Lakehouse Monitoring — Automated profiling and drift detection for Delta tables
• Inference tables — Automatically log all prediction requests and responses from serving endpoints
• Data drift — Statistical comparison of input feature distributions between training and serving data
• Model quality — Compare prediction accuracy against ground truth labels (when available)

Practice Questions

Question 1 — Model Registry

Question 2 — Model Serving

Question 3 — Batch Inference

Question 4 — Traffic Splitting

Question 5 — Model Loading