Machine Learning Academy · Lektion

Modellregister: Staging, produktion och arkivering

Ni kommer att registrera en modellversion i MLflow Model Registry, flytta den från Staging till Production och skriva ett befordringsflöde med Python-API:t.

Lektion 3 av 413 steg

Modellregister: Staging, produktion och arkivering är en gratis lektion i Machine Learning Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Machine Learning Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.

Vad är ett modellregister?

Ett modellregister är en centraliserad katalog som lagrar versionshanterade tränade modeller med tillhörande metadata. I stället för att hantera modellfiler som är utspridda i olika filsystem erbjuder ett register en gemensam källa med namngivna versioner, livscykelstadier (Staging, Production, Archived) och sökbara anteckningar. MLflow Model Registry är den mest använda lösningen med öppen källkod och integreras direkt med MLflows spårningsserver.

Registrera en modell från en körning

Efter träningen registrerar du modellen genom att länka den till en befintlig MLflow-körningsartefakt. Du kan registrera den direkt vid loggningen med argumentet registered_model_name eller i efterhand med MLflow-klienten. Registret skapar en namngiven modellpost, till exempel 'SentimentClassifier', och tilldelar den Version 1. Efterföljande registreringar av samma modellnamn ökar automatiskt versionsnumret.

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier

# Option 1: Register during logging
with mlflow.start_run():
    clf = RandomForestClassifier(n_estimators=100, random_state=42)
    # clf.fit(X_train, y_train)
    mlflow.sklearn.log_model(
        sk_model=clf,
        artifact_path='model',
        registered_model_name='SentimentClassifier'  # auto-registers
    )
    print('Model registered as SentimentClassifier v1')

Använda MLflow-klienten för registeråtgärder

Python-API:t MlflowClient ger programmatisk kontroll över registret. Använd det för att registrera modeller från befintliga körningsartefakter, byta livscykelstadium och lägga till beskrivningar — allt från skript i stället för användargränssnittet. Detta är viktigt för automatiserade CI/CD-pipelines där en ny modell endast ska befordras efter godkända utvärderingstester, utan att en data scientist behöver använda användargränssnittet manuellt.

from mlflow.tracking import MlflowClient

client = MlflowClient(tracking_uri='http://localhost:5000')

# Option 2: Register from an existing run artifact
run_id = 'abc123def456'  # get this from mlflow.last_active_run().info.run_id
model_uri = f'runs:/{run_id}/model'

model_version = mlflow.register_model(
    model_uri=model_uri,
    name='SentimentClassifier'
)
print('Version:', model_version.version)
print('Status:', model_version.status)  # PENDING_REGISTRATION -> READY

Livscykelstadier: None, Staging, Production, Archived

Varje modellversion i registret har ett livscykelstadium. Nya versioner börjar i None. När den automatiska utvärderingen har godkänts befordrar du versionen till Staging för integrationstestning. När Staging har godkänts befordrar du den till Production — versionen som hanterar trafik i produktion. När en nyare version ersätter den flyttar du den till Archived för att bevara historiken utan att ta bort den. Endast en version bör vara i Production åt gången för varje modellnamn.

from mlflow.tracking import MlflowClient

client = MlflowClient()

# Transition version 1 to Staging
client.transition_model_version_stage(
    name='SentimentClassifier',
    version='1',
    stage='Staging',
    archive_existing_versions=False
)
print('Version 1 -> Staging')

# After testing, promote to Production (archives previous Production)
client.transition_model_version_stage(
    name='SentimentClassifier',
    version='1',
    stage='Production',
    archive_existing_versions=True  # auto-archives old Production
)
print('Version 1 -> Production')

Lägga till beskrivningar och taggar för versioner

Modellversioner bör ha metadata som är begriplig för människor. Lägg till en beskrivning som förklarar vad som ändrades i versionen: träningsdata, förbehandling eller algoritm. Lägg till taggar för snabb filtrering, till exempel distributionsmiljö eller datauppsättningens version. Bra metadata gör det möjligt att besvara granskningsfrågor (”Vilken modell användes i produktion i februari?”) flera månader efter distributionen utan att behöva gå igenom Git-historiken.

from mlflow.tracking import MlflowClient

client = MlflowClient()

# Add description to version
client.update_model_version(
    name='SentimentClassifier',
    version='1',
    description=('RandomForest trained on IMDB v2 (50k reviews). '
                 'Test accuracy 0.924, F1 0.921. '
                 'Replaces rule-based baseline.')
)

# Add tags for filtering and search
client.set_model_version_tag(
    name='SentimentClassifier',
    version='1',
    key='dataset',
    value='imdb_v2'
)
client.set_model_version_tag('SentimentClassifier', '1', 'algorithm', 'random_forest')
print('Description and tags added.')

Ladda produktionsmodellen för inferens

I er inference-tjänst ska ni alltid läsa in modellen med ett alias för stadiet ('Production') i stället för ett hårdkodat versionsnummer. På så sätt använder inference-tjänsten automatiskt den nya modellen vid nästa inläsning när ni befordrar en ny version till Production, utan att koden behöver ändras. URI-schemat models:/ är en kraftfull MLflow-konvention för stadiebaserad inläsning.

import mlflow.sklearn

# Load the current Production model by stage
model_name = 'SentimentClassifier'
stage = 'Production'
model_uri = f'models:/{model_name}/{stage}'

production_model = mlflow.sklearn.load_model(model_uri)
print('Loaded model from:', model_uri)

# Or load a specific version
version_uri = f'models:/{model_name}/1'
v1_model = mlflow.sklearn.load_model(version_uri)
print('Loaded specific version 1')

# Make predictions
# predictions = production_model.predict(X_new)

Söka efter och jämföra versioner

När allt fler versioner samlas använder ni klientens sökmetoder för att filtrera efter stadie, taggar eller mätvärden. Jämför versionernas prestanda programmatiskt: hämta det körnings-ID som hör till varje version, läs körningens mätvärden och hitta den version som presterar bäst för befordran. Den här automatiseringen förebygger manuella fel och säkerställer att beslut om befordran baseras på objektiva jämförelser av mätvärden i stället för gissningar.

from mlflow.tracking import MlflowClient

client = MlflowClient()

# List all versions of a model
versions = client.search_model_versions("name='SentimentClassifier'")
for v in versions:
    print(f'Version {v.version}: stage={v.current_stage}, run_id={v.run_id[:8]}')

# Get the metric from the associated training run
for v in versions:
    run = client.get_run(v.run_id)
    acc = run.data.metrics.get('test_accuracy', 'N/A')
    print(f'  Version {v.version} accuracy: {acc}')

Automatiserat skript för befordran

En pipeline för omträning bör automatiskt befordra en ny modell till Staging endast om den presterar bättre än den aktuella Production-modellen på en undanhållen utvärderingsmängd. Detta champion/challenger-mönster förhindrar regression: Production-modellen är champion och den nya modellen är challenger. Challenger-modellen befordras endast om den överträffar champion-modellen enligt det överenskomna mätvärdet, till exempel F1 på valideringsmängden.

from mlflow.tracking import MlflowClient
import mlflow.sklearn

client = MlflowClient()

def get_metric(run_id, metric_name):
    return client.get_run(run_id).data.metrics.get(metric_name, 0)

def promote_if_better(model_name, challenger_version, metric='test_f1'):
    # Get current production version
    prod_versions = client.get_latest_versions(model_name, stages=['Production'])
    if not prod_versions:
        print('No production model found -- promoting challenger directly.')
        client.transition_model_version_stage(model_name, challenger_version, 'Production')
        return

    prod_v = prod_versions[0]
    prod_score = get_metric(prod_v.run_id, metric)
    chall_run_id = client.get_model_version(model_name, challenger_version).run_id
    chall_score = get_metric(chall_run_id, metric)

    print(f'Champion {metric}: {prod_score:.4f}  Challenger: {chall_score:.4f}')
    if chall_score > prod_score:
        client.transition_model_version_stage(model_name, challenger_version,
                                              'Production', archive_existing_versions=True)
        print('Challenger promoted to Production!')
    else:
        print('Champion retained.')

Arkivera ersatta modeller

När en ny version går in i Production bör gamla Production-versioner flyttas till Archived i stället för att tas bort. Arkiverade modeller utesluts från frågor med get_latest_versions, men kan fortfarande laddas ned för granskning, återställning eller framtida jämförelser. Ta aldrig bort modellversioner i en reglerad bransch: finansiella tjänster och hälso- och sjukvård kräver en fullständig versionshistorik för efterlevnadsrevisioner.

from mlflow.tracking import MlflowClient

client = MlflowClient()

# Manually archive a specific version
client.transition_model_version_stage(
    name='SentimentClassifier',
    version='1',
    stage='Archived'
)
print('Version 1 archived.')

# List only archived versions
archived = client.search_model_versions(
    "name='SentimentClassifier' and stage='Archived'"
)
for v in archived:
    print(f'Archived: v{v.version} created {v.creation_timestamp}')

Model Serving med mlflow models serve

MLflow kan exponera alla registrerade modeller som ett lokalt REST API med ett enda kommando. Slutpunkten tar emot JSON-nyttolaster och returnerar prediktioner. Detta är användbart för snabb prototypframtagning och integrationstester innan modellen distribueras till en molnplattform. För produktion bör ni använda containerbaserad serving (Docker + FastAPI eller MLflows Docker-export) för bättre skalbarhet och övervakning.

# Serve the Production model as a local REST endpoint
# mlflow models serve -m 'models:/SentimentClassifier/Production' --port 8080

# Then call it with curl:
# curl -X POST http://localhost:8080/invocations \
#   -H 'Content-Type: application/json' \
#   -d '{"dataframe_records": [{"feature1": 0.5, "feature2": 1.2}]}'

# Or with Python requests:
import requests
data = {'dataframe_records': [{'feature1': 0.5, 'feature2': 1.2}]}
response = requests.post('http://localhost:8080/invocations', json=data)
print('Prediction:', response.json())

Webhooks och aviseringar i registret

MLflow Registry (i Databricks och vissa företagsmiljöer) har stöd för webhooks som skickar HTTP-callbacks när modellövergångar sker. I open source-versionen av MLflow kan ni simulera webhooks genom att läsa av registret regelbundet i ett cron-jobb. Vanliga automatiseringsmönster är att skicka en Slack-avisering när en modell går in i Staging, utlösa integrationstester när en modell når Staging och avisera teamet när Production uppdateras.

# Polling script (run on a schedule, e.g., cron every 5 minutes)
from mlflow.tracking import MlflowClient
import json
import os

client = MlflowClient()
state_file = '/tmp/model_registry_state.json'

def load_state():
    if os.path.exists(state_file):
        return json.load(open(state_file))
    return {}

def save_state(state):
    json.dump(state, open(state_file, 'w'))

state = load_state()
prod = client.get_latest_versions('SentimentClassifier', stages=['Production'])
if prod:
    current_prod = prod[0].version
    if state.get('production_version') != current_prod:
        print(f'ALERT: Production changed to version {current_prod}')
        # send_slack_notification(current_prod)
        state['production_version'] = current_prod
        save_state(state)

Snabbkontroll

Testa er förståelse av koncepten inom Machine Learning with Python från den här lektionen.

Besvara frågan i den interaktiva lektionen

Sammanfattning av lektionen

I den här lektionen har ni lärt er att MLflow Model Registry tillhandahåller versionshantering av modeller med livscykelstadierna: None, Staging, Production och Archived, att läsa in modeller med aliaset för stadiet ('Production') i stället för versionsnumret för att möjliggöra smidiga uppdateringar utan kodändringar och att automatiserade skript för befordran implementerar champion/challenger-mönstret för att förhindra regressioner i produktion. Härnäst bygger vi ett GitHub Actions-arbetsflöde som automatiskt tränar om och befordrar en modell när nya data blir tillgängliga.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 30
Lektioner: 120

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Modellregister: Staging, produktion och arkivering” gratis?

Ja – hela texten till ”Modellregister: Staging, produktion och arkivering” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Machine Learning Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Modellregister: Staging, produktion och arkivering”?

Ni kommer att registrera en modellversion i MLflow Model Registry, flytta den från Staging till Production och skriva ett befordringsflöde med Python-API:t. Ni övar på Machine Learning Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Machine Learning Academy?

Du behöver inga förkunskaper. Utbildningen i Machine Learning Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Modellregister: Staging, produktion och arkivering”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Machine Learning Academy-lektionen?

Ja. Varje Machine Learning Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Experimentuppföljning med MLflow: Logga parametrar, mått och artefakter
Reproducerbara miljöer med Docker för maskininlärning
Modellregister: Staging, produktion och arkivering
Automatiserade omträningspipelines med GitHub Actions

← Tillbaka till Machine Learning Academy