Blog

Operationalizing machine learning models has become a cornerstone of modern data science. Azure Machine Learning (AzureML) is a robust platform that supports MLOps workflows—helping teams develop, deploy, monitor, and manage machine learning models across environments. In this article, we’ll explore how to use AzureML for MLOps, including best practices, tools for development and orchestration, and managing model lifecycle effectively.

---

AzureML Environments and Their Role in MLOps

AzureML environments are isolated, reproducible computational settings that ensure consistency across development, testing, and production phases. These environments encapsulate dependencies, libraries, and configurations required to run machine learning models.

Key AzureML Environments:

1. Development Environment (DEV):
   • Used for experimentation and prototyping.
   • Data scientists iterate on features, algorithms, and parameters.
   • Integration with Jupyter Notebooks or VS Code for interactive development.
2. Testing Environment (TEST):
   • Used to validate models and pipelines.
   • Ensures that the model behaves correctly under varied conditions.
   • Automated testing frameworks are integrated here.
3. Production Environment (PROD):
   • Hosts deployed models serving real-world predictions.
   • Focuses on scalability, reliability, and performance monitoring.

How to Set Up AzureML Environments

from azureml.core import Environment

# Create an AzureML environment
env = Environment(name="ml_env")

# Configure dependencies
conda_dependencies = ["pandas", "scikit-learn", "numpy"]
env.python.conda_dependencies.add_pip_package(conda_dependencies)

# Save environment configuration
env.register(workspace=ws)
print("Environment registered successfully.")

---

Model Registration: MLflow vs AzureML Model Registry

Model registration is essential for managing multiple versions of machine learning models. Both MLflow and AzureML provide robust registries, but they have different strengths.

MLflow Model Registry:

• Strengths:
  • Open-source and platform-agnostic.
  • Integrated with many popular ML tools.
  • Tracks model versions, metadata, and stages (e.g., Staging, Production).
• Example:

import mlflow

# Register a model in MLflow
mlflow.log_model(model, "model-path")
mlflow.register_model("runs:/<run_id>/model", "my_model")

# Transition model to production
mlflow.registered_model.ModelVersion(
    name="my_model", version="1"
).transition_stage("Production")

AzureML Model Registry:

• Strengths:
  • Deep integration with Azure services.
  • Supports deployment directly from the registry.
  • Offers role-based access control (RBAC).
• Example:

from azureml.core import Model

# Register a model in AzureML
model = Model.register(workspace=ws,
                       model_name="my_model",
                       model_path="outputs/model.pkl")

# List registered models
for model in Model.list(ws):
    print(model.name, model.version)

Choosing Between MLflow and AzureML

If your organization relies heavily on Azure, the AzureML registry’s seamless integration with Azure services might make it the better choice. For hybrid setups or open-source flexibility, MLflow may be ideal.

---

Managing Models: Versioning and Cleanup

When to Consider a Model “Old”

A model becomes outdated when:

• A new version consistently outperforms it on key metrics.
• Data drift reduces its prediction accuracy.
• The business objective shifts, making the model less relevant.

Removing Older Models from the Registry

In AzureML, you can automate the cleanup process to delete models older than a specified version:

from azureml.core import Model

# List and delete older versions
models = Model.list(ws, name="my_model")
latest_version = max(model.version for model in models)

for model in models:
    if model.version < latest_version:
        model.delete()
        print(f"Deleted model version: {model.version}")

This ensures your registry remains manageable and cost-efficient.

---

Sharing Models Across Environments (DEV, TEST, PROD)

Promoting Models Across Environments

Models are promoted across environments using deployment pipelines. For example, a model trained in DEV can be validated in TEST and then deployed to PROD if it meets the performance criteria.

Steps for Model Promotion:

1. Export the Model:
   • Save the model artifact.
   • Use AzureML’s Model.package() to prepare the model for deployment.
2. Deploy the Model:
   • Deploy the exported model to the target environment.
   • Use Azure DevOps or GitHub Actions for automation.

from azureml.core import Model, Environment

# Deploy to production
inference_config = InferenceConfig(entry_script="score.py", environment=env)
deployment_config = AciWebservice.deploy_configuration(cpu_cores=1, memory_gb=1)

service = Model.deploy(workspace=ws,
                        name="prod-service",
                        models=[model],
                        inference_config=inference_config,
                        deployment_config=deployment_config)
service.wait_for_deployment(show_output=True)
print(service.state)

---

Version Control with Git and Pre-commit Hooks

Using Git to Manage Code

Version control is essential for collaborative and reproducible data science workflows. Git is the most popular tool for tracking changes in code.

Setting Up Git:

1. Initialize a Git repository: git init
2. Commit your changes: git add . git commit -m "Initial commit"
3. Push to a remote repository: git remote add origin <repository-url> git push -u origin main

Pre-commit Hooks for Quality Assurance

Pre-commit hooks enforce code quality by running checks before committing changes. Tools like Ruff and Trivy can be integrated into these hooks.

Example Pre-commit Configuration:

Create a .pre-commit-config.yaml file:

repos:
  - repo: https://github.com/astral-sh/ruff
    rev: v0.12.1
    hooks:
      - id: ruff

  - repo: https://github.com/aquasecurity/trivy
    rev: v0.32.0
    hooks:
      - id: trivy

Install pre-commit hooks:

pre-commit install

Now, every commit will trigger Ruff and Trivy checks, ensuring high-quality code.

---

Integrating Azure Pipelines with AzureML

Azure Pipelines automates CI/CD workflows, streamlining the process of pushing models, managing registries, and deploying services.

Example Azure Pipeline for ML:

trigger:
  - main

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: UsePythonVersion@1
  inputs:
    versionSpec: '3.x'
    addToPath: true

- script: |
    pip install azureml-sdk
    python train_and_register.py
  displayName: 'Train and Register Model'

- script: |
    python deploy_model.py
  displayName: 'Deploy Model'

This pipeline automates training, registration, and deployment tasks whenever code changes are pushed.

---

Conclusion

AzureML provides a powerful ecosystem for implementing MLOps practices. By leveraging its environments, model registry, and seamless integration with tools like Git, Ruff, and Trivy, data science teams can ensure scalability, reliability, and efficiency. Automating workflows using Azure Pipelines further enhances collaboration and accelerates deployment cycles.

Integrating these practices into your workflows not only professionalizes your data science projects but also sets the foundation for delivering consistent and impactful machine learning solutions. With AzureML, the journey from development to production becomes more streamlined and robust, empowering teams to focus on innovation and value delivery.