Model Registry: staging, produzione e archiviazione
Imparerete a registrare una versione del modello nel MLflow Model Registry, farla passare da Staging a Production e programmare un workflow di promozione con la Python API.
Model Registry: staging, produzione e archiviazione è una lezione Machine Learning Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Machine Learning Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Machine Learning Academy include 4 lezioni in totale.
Che cos'è un Model Registry?
Un model registry è un catalogo centralizzato che archivia modelli addestrati versionati insieme ai relativi metadati. Invece di gestire file di modello sparsi in diversi file system, un registry offre un'unica fonte di verità con versioni denominate, fasi del ciclo di vita (Staging, Production, Archived) e annotazioni consultabili. MLflow Model Registry è la soluzione open source più utilizzata e si integra direttamente con il server di tracking MLflow.
Registrare un modello da un'esecuzione
Dopo l'addestramento, registri il modello collegandolo a un artefatto di un'esecuzione MLflow esistente. Può registrarlo direttamente durante la registrazione dei dati utilizzando l'argomento registered_model_name oppure in un secondo momento tramite il client MLflow. Il registry crea una voce di modello denominata, ad esempio 'SentimentClassifier', e le assegna la Version 1. Le registrazioni successive dello stesso nome di modello incrementano automaticamente il numero di versione.
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')Utilizzare il client MLflow per le operazioni sul registry
L'API Python MlflowClient consente di controllare programmaticamente il registry. La utilizzi per registrare modelli da artefatti di esecuzioni esistenti, modificarne le fasi e aggiungere descrizioni, il tutto tramite script anziché dall'interfaccia utente. È essenziale per le pipeline CI/CD automatizzate, nelle quali un nuovo modello deve essere promosso solo dopo aver superato i test di valutazione, senza richiedere l'intervento manuale di un data scientist nell'interfaccia utente.
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 -> READYFasi del ciclo di vita: None, Staging, Production, Archived
Ogni versione di un modello nel registry ha una fase del ciclo di vita. Le nuove versioni iniziano in None. Dopo aver superato la valutazione automatizzata, vengono promosse a Staging per i test di integrazione. Dopo aver superato Staging, vengono promosse a Production, la versione che gestisce il traffico reale. Quando una versione più recente la sostituisce, la si sposta in Archived per conservarne la cronologia senza eliminarla. Per ogni nome di modello, in Production dovrebbe trovarsi una sola versione alla volta.
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')Aggiungere descrizioni e tag alle versioni
Le versioni dei modelli dovrebbero contenere metadati comprensibili. Aggiunga una descrizione che spieghi cosa è cambiato in questa versione: dati di addestramento, preprocessing o algoritmo. Aggiunga tag per applicare rapidamente filtri, ad esempio relativi all'ambiente di deployment o alla versione del dataset. Metadati ben organizzati consentono di rispondere a domande di audit, come «Quale modello era in produzione a febbraio?», anche a distanza di mesi dal deployment, senza dover consultare la cronologia di git.
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.')Caricare il modello in produzione per l'inferenza
Nel servizio di inferenza, carichi sempre il modello tramite l'alias dello stage ('Production') anziché usare un numero di versione codificato nel codice. In questo modo, quando promuove una nuova versione a Production, il servizio di inferenza utilizza automaticamente il nuovo modello al caricamento successivo, senza modifiche al codice. Lo schema URI models:/ è una potente convenzione di MLflow per il caricamento basato sugli stage.
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)Ricerca e confronto delle versioni
Man mano che si accumulano nuove versioni, utilizzi i metodi di ricerca del client per filtrare in base a stage, tag o metriche. Confronti programmaticamente le prestazioni delle versioni: recuperi il run ID associato a ciascuna versione, interroghi le metriche della run e individui la versione con le prestazioni migliori da promuovere. Questa automazione previene gli errori manuali e garantisce che le decisioni di promozione si basino sul confronto di metriche oggettive, anziché su supposizioni.
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}')Script di promozione automatica
Una pipeline di retraining dovrebbe promuovere automaticamente un nuovo modello a Staging solo se supera il modello attualmente in Production su un set di valutazione tenuto da parte. Questo pattern champion/challenger previene le regressioni: il modello in Production è il champion, mentre il nuovo modello è il challenger. Il challenger viene promosso solo se supera il champion sulla metrica concordata, ad esempio l'F1 sul set di validazione.
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.')Archiviazione dei modelli superati
Quando una nuova versione entra in Production, le vecchie versioni in Production dovrebbero passare ad Archived anziché essere eliminate. I modelli archiviati sono esclusi dalle query get_latest_versions, ma rimangono scaricabili per audit, rollback o confronti futuri. Non elimini mai le versioni dei modelli in un settore regolamentato: i servizi finanziari e la sanità richiedono la cronologia completa delle versioni per gli audit di conformità.
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 con mlflow models serve
MLflow può esporre qualsiasi modello registrato come API REST locale con un solo comando. L'endpoint accetta payload JSON e restituisce previsioni. Questa soluzione è utile per la prototipazione rapida e i test di integrazione prima della distribuzione su una piattaforma cloud. In produzione, utilizzi un servizio basato su container (Docker + FastAPI oppure l'esportazione Docker di MLflow) per ottenere maggiore scalabilità e un monitoraggio migliore.
# 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())Webhook e notifiche del registry
MLflow Registry (in Databricks e in alcune configurazioni aziendali) supporta i webhook, che inviano callback HTTP quando si verificano transizioni dei modelli. Per MLflow open source, simuli i webhook eseguendo il polling del registry in un cron job. Tra i pattern di automazione più comuni ci sono: inviare una notifica Slack quando un modello entra in Staging, avviare i test di integrazione quando un modello raggiunge Staging e avvisare il team quando Production viene aggiornata.
# 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)Verifica rapida
Verifichi la sua comprensione dei concetti di Machine Learning con Python presentati in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che MLflow Model Registry fornisce l'archiviazione dei modelli con versioni e con gli stage del ciclo di vita: None, Staging, Production e Archived, che è opportuno caricare i modelli tramite l'alias dello stage ('Production') anziché tramite il numero di versione, per consentire aggiornamenti senza interruzioni e senza modifiche al codice e che gli script di promozione automatica implementano il pattern champion/challenger per prevenire le regressioni in produzione. Nel prossimo argomento creeremo un workflow GitHub Actions che esegue automaticamente il retraining e promuove un modello quando arrivano nuovi dati.
Impara Python con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 30
- Lezioni
- 120
Domande Frequenti
La lezione «Model Registry: staging, produzione e archiviazione» è gratuita?
Sì — il testo completo di «Model Registry: staging, produzione e archiviazione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Machine Learning Academy, passa a CoddyKit PRO. Il corso Machine Learning Academy include 4 lezioni in totale.
Cosa imparerò in «Model Registry: staging, produzione e archiviazione»?
Imparerete a registrare una versione del modello nel MLflow Model Registry, farla passare da Staging a Production e programmare un workflow di promozione con la Python API. Eserciti Machine Learning Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Machine Learning Academy?
Non è richiesta alcuna esperienza precedente. Machine Learning Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Model Registry: staging, produzione e archiviazione»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Machine Learning Academy?
Sì. Ogni lezione Machine Learning Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Tracciamento degli esperimenti con MLflow: registrare parametri, metriche e artifact
- Ambienti riproducibili con Docker per il machine learning
- Model Registry: staging, produzione e archiviazione
- Pipeline di riaddestramento automatico con GitHub Actions