Conditionally Registering Models for Deployment

Introduction & Lesson Overview

Welcome to the final lesson in your pipeline journey! Over the past four lessons, you've built an impressive foundation that processes raw California housing data, trains a Linear Regression model, and systematically evaluates performance using multiple regression metrics. However, there's one critical gap that separates your current workflow from a truly production-ready ML system: your pipeline doesn't make intelligent decisions about what to do with evaluation results. In this culminating lesson, you'll complete your transformation from ML practitioner to MLOps engineer by implementing intelligent, conditional model deployment. You'll learn to implement conditional logic that automatically registers only high-performing models for deployment, ensuring that your production systems receive models that meet your quality standards. This represents the ultimate evolution from manual model promotion processes to fully automated, criteria-based deployment workflows. By the end of this lesson, you'll have achieved the holy grail of ML automation — a complete, end-to-end pipeline that takes raw data and automatically produces production-ready inference endpoints, but only when models meet your quality criteria. You'll master deploying approved models using SageMaker's model registry capabilities, completing your journey from raw data to production-ready ML systems with zero manual intervention.

Recap of the Pipeline and Evaluation Metrics

Before diving into conditional deployment logic, let's briefly revisit the solid foundation you've built in previous lessons. Your current pipeline consists of three well-orchestrated steps that work together seamlessly. The preprocessing step transforms raw California housing data into clean training and test datasets, handling feature scaling and data splitting automatically. The training step uses the processed training data to fit a Linear Regression model, saving the trained model artifact to S3 for future use. Finally, the evaluation step takes both the trained model and test data to calculate comprehensive performance metrics. The evaluation step you implemented in the previous lesson is particularly important for what we're about to build. As a reminder, this step extracts the trained model from its compressed archive, loads the test data, generates predictions, and calculates key regression metrics. These metrics are then saved in a structured JSON format using SageMaker's Property Files feature, making them accessible to subsequent pipeline steps. The Property Files mechanism you learned about is crucial for the conditional logic we're about to implement. When your evaluation step completes, it creates an evaluation.json file containing all the performance metrics in a structured format. This file becomes available to downstream pipeline steps through the PropertyFile configuration, allowing future steps to programmatically access specific metrics like the R-squared score. This capability transforms your evaluation results from simple reports into actionable data that can drive automated decision-making within your pipeline.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Creating the Serving Model Object

First, we'll create the serving model object that defines how the trained model should be packaged for inference:

Python

from sagemaker.sklearn.model import SKLearnModel

# Create a serving model object with a minimal inference script
inference_model = SKLearnModel(
    role=SAGEMAKER_ROLE,                                                  # IAM role for model execution
    model_data=training_step.properties.ModelArtifacts.S3ModelArtifacts,  # Reference to trained model
    entry_point="entry_point.py",                                         # Our minimal inference script
    framework_version="1.2-1",                                            # Scikit-learn framework version
    py_version="py3",                                                     # Python version for inference
    sagemaker_session=pipeline_session                                    # Pipeline session for execution
)

from sagemaker.sklearn.model import SKLearnModel

# Create a serving model object with a minimal inference script
inference_model = SKLearnModel(
    role=SAGEMAKER_ROLE,                                                  # IAM role for model execution
    model_data=training_step.properties.ModelArtifacts.S3ModelArtifacts,  # Reference to trained model
    entry_point="entry_point.py",                                         # Our minimal inference script
    framework_version="1.2-1",                                            # Scikit-learn framework version
    py_version="py3",                                                     # Python version for inference
    sagemaker_session=pipeline_session                                    # Pipeline session for execution
)

The SKLearnModel class serves as a bridge between your trained model artifacts and SageMaker's deployment infrastructure, providing essential metadata and configuration that the model registry and inference endpoints require.

When you register a model using SKLearnModel, you're not just storing the model weights — you're creating a complete deployment package that includes:

Framework specification: Tells SageMaker which scikit-learn version and Python version to use
Entry point definition: Specifies which script contains the inference logic
Execution role: Defines the IAM permissions needed for model deployment
Container configuration: Sets up the proper runtime environment for your model

The model registry needs this comprehensive information to ensure that anyone deploying the model later will have all the necessary components and configuration. Without SKLearnModel, the registry would only have the raw model file without the context needed for successful deployment.

This approach also enables deployment portability — once a model is registered with all its deployment metadata, it can be deployed by different teams, in different environments, or at different times, all while maintaining consistent behavior and requirements.

Configuring Model Registration

Before configuring the model registration step, let's define the model package group name that will organize our registered models in SageMaker's model registry:

Python

# Define the model package group name for organizing registered models
MODEL_PACKAGE_GROUP_NAME = "california-housing-pipeline-models"

# Define the model package group name for organizing registered models
MODEL_PACKAGE_GROUP_NAME = "california-housing-pipeline-models"

The model package group is like a folder in SageMaker's model registry that keeps all versions of your California housing models organized in one place. Each time your pipeline runs and approves a model, it will create a new version within this group, allowing you to track how your models improve over time.

Next, we'll configure the model registration step that will store approved models in SageMaker's model registry:

Python

from sagemaker.workflow.step_collections import RegisterModel

# Configure the model registration step
register_step = RegisterModel(
    name="RegisterModel",                               # Step name in the pipeline
    model=inference_model,                              # The serving model we just created
    content_types=["text/csv"],                         # Input format the model accepts
    response_types=["text/csv"],                        # Output format the model produces
    inference_instances=["ml.m5.large"],                # Approved instance types for real-time inference
    transform_instances=["ml.m5.large"],                # Approved instance types for batch transform
    model_package_group_name=MODEL_PACKAGE_GROUP_NAME,  # Registry group name
    approval_status="Approved"                          # Automatically approve registered models
)

from sagemaker.workflow.step_collections import RegisterModel

# Configure the model registration step
register_step = RegisterModel(
    name="RegisterModel",                               # Step name in the pipeline
    model=inference_model,                              # The serving model we just created
    content_types=["text/csv"],                         # Input format the model accepts
    response_types=["text/csv"],                        # Output format the model produces
    inference_instances=["ml.m5.large"],                # Approved instance types for real-time inference
    transform_instances=["ml.m5.large"],                # Approved instance types for batch transform
    model_package_group_name=MODEL_PACKAGE_GROUP_NAME,  # Registry group name
    approval_status="Approved"                          # Automatically approve registered models
)

The RegisterModel step takes your trained model and creates a permanent record of it in SageMaker's model registry. Remember that the inference_model parameter references the SKLearnModel object we created earlier, which packages your trained Linear Regression model with the entry_point.py script needed for making predictions.

Let's break down the key parameters:

content_types and response_types: These specify the data formats your model can handle. By setting both to ["text/csv"], you're telling SageMaker that this model accepts CSV input data (like housing features) and returns CSV output (predicted prices). This matches the format of your California housing dataset and ensures proper data handling during inference.
inference_instances and transform_instances: These define the EC2 instance types that are approved for deploying this model. inference_instances specifies what resources can be used for real-time endpoints (where you send individual prediction requests), while transform_instances specifies resources for batch transform jobs (where you process large datasets at once). By setting both to ["ml.m5.large"], you're pre-approving this cost-effective instance type for both deployment scenarios.
approval_status="Approved": This is a crucial parameter that automatically marks registered models as approved for deployment. Without this setting, models would be registered with a "PendingManualApproval" status, requiring someone to manually review and approve each model in the SageMaker console before it can be deployed. By setting this to "Approved", your pipeline can fully automate the deployment workflow — since your conditional logic already ensures only high-quality models reach this registration step, there's no need for additional manual approval gates.

This automated approval approach is essential for achieving true end-to-end automation. Your pipeline has already validated model quality through the conditional step, so manual approval would create an unnecessary bottleneck that defeats the purpose of automated MLOps workflows.

Querying the Model Registry for Approved Models

After your pipeline has successfully executed and registered an approved model, you can deploy it independently from a different environment or at a later time. This separation between training and deployment workflows is a best practice in MLOps, allowing you to deploy models on different schedules and test deployment configurations without re-running the entire training pipeline.

Since this is your first time working with SageMaker's model registry, let's understand what happened when your pipeline registered the model. The model registry acts as a centralized catalog that stores different versions of your models along with their metadata, approval status, and deployment artifacts. Each registered model receives a unique identifier called an ARN (Amazon Resource Name) that you can use to reference and deploy that specific model version.

To deploy an approved model, you'll first need to query the model registry to find the latest approved model from your pipeline. This works similarly to how you've searched for training jobs before, but instead of looking for training job names, you're searching for model packages within a specific group:

Python

import sagemaker

# Create a SageMaker session
sagemaker_session = sagemaker.Session()

# Get the SageMaker client from the session
sagemaker_client = sagemaker_session.sagemaker_client

# List approved model packages from the group, sorted by creation time
response = sagemaker_client.list_model_packages(
    ModelPackageGroupName="california-housing-pipeline-models",
    ModelApprovalStatus='Approved',
    SortBy='CreationTime',
    SortOrder='Descending'
)

import sagemaker

# Create a SageMaker session
sagemaker_session = sagemaker.Session()

# Get the SageMaker client from the session
sagemaker_client = sagemaker_session.sagemaker_client

# List approved model packages from the group, sorted by creation time
response = sagemaker_client.list_model_packages(
    ModelPackageGroupName="california-housing-pipeline-models",
    ModelApprovalStatus='Approved',
    SortBy='CreationTime',
    SortOrder='Descending'
)

The list_model_packages function works similarly to the training job listing you've used before, but it searches within a specific model package group and filters by approval status. The SortBy='CreationTime' and SortOrder='Descending' parameters ensure you get the most recently approved model first.

Deploying the Approved Model

Now that you have the ARN of your approved model, you can deploy it using the same serverless deployment approach you've used before. However, instead of deploying a model object created from training artifacts, you'll deploy a ModelPackage object created from the registry entry:

Python

from sagemaker.model import ModelPackage
from sagemaker.serverless import ServerlessInferenceConfig

# Create a ModelPackage object from the ARN
model = ModelPackage(
    role=SAGEMAKER_ROLE,
    model_package_arn=model_package_arn,
    sagemaker_session=sagemaker_session
)

# Configure serverless inference with memory and concurrency limits
serverless_config = ServerlessInferenceConfig(
    memory_size_in_mb=2048,
    max_concurrency=10
)

# Deploy the model as a serverless endpoint
predictor = model.deploy(
    serverless_inference_config=serverless_config,
    endpoint_name="california-housing-estimator",
    wait=False
)

from sagemaker.model import ModelPackage
from sagemaker.serverless import ServerlessInferenceConfig

# Create a ModelPackage object from the ARN
model = ModelPackage(
    role=SAGEMAKER_ROLE,
    model_package_arn=model_package_arn,
    sagemaker_session=sagemaker_session
)

# Configure serverless inference with memory and concurrency limits
serverless_config = ServerlessInferenceConfig(
    memory_size_in_mb=2048,
    max_concurrency=10
)

# Deploy the model as a serverless endpoint
predictor = model.deploy(
    serverless_inference_config=serverless_config,
    endpoint_name="california-housing-estimator",
    wait=False
)

The key difference here is that you're creating a ModelPackage object instead of an SKLearnModel object. The ModelPackage automatically includes all the deployment configuration (entry point script, framework version, etc.) that was specified when the model was registered by your pipeline. This approach demonstrates the power of the model registry — all the deployment details are packaged with the model, making deployment consistent and repeatable.

This deployment workflow represents the final piece of your end-to-end MLOps system. Your pipeline trains and evaluates models automatically, registers only those that meet quality standards, and now you can deploy approved models independently whenever needed. This separation allows you to maintain different deployment schedules, test various deployment configurations, and roll back to previous model versions if needed.

Introduction & Lesson Overview

Recap of the Pipeline and Evaluation Metrics

Join the 1M+ learners on CodeSignal

Understanding Conditional Model Approval

Creating a Lightweight Inference Model

Implementing the Conditional Registration Step

Creating the Serving Model Object

Configuring Model Registration

Defining the Quality Condition

Creating the Conditional Step

Integrating the Conditional Step into the Pipeline

Querying the Model Registry for Approved Models

Extracting the Model Package ARN

Deploying the Approved Model

Lesson Summary