Versionshantera modeller: Varför filnamn och metadata spelar roll
Ni kommer att utforma en namnkonvention som innehåller träningsdatum, datamängdsversion och metriktal samt skriva en JSON-sidofil med metadata för styrning.
Versionshantera modeller: Varför filnamn och metadata spelar roll är en gratis lektion i Machine Learning Academy på CoddyKit. Detta är lektion 2 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.
Problemet utan versionshantering
Utan en disciplinerat tillämpad strategi för versionshantering samlar team snabbt på sig filer som model.pkl, model_v2.pkl, model_final.pkl och model_FINAL_v2.pkl, utan information om vilka data som användes vid träningen, vilket mätvärde modellen uppnådde eller vilken modell som faktiskt körs i produktion. Detta kaos leder till att gamla modeller distribueras, att den bästa kontrollpunkten går förlorad eller att ett tidigare resultat inte kan återskapas för felsökning.
Vad som ska kodas in i filnamnet
Ett bra modellfilnamn bör innehålla tillräckligt med sammanhang för att vara självbeskrivande: datauppsättning, algoritm, datum och valfritt det primära mätvärdet samt datauppsättningens version eller Git SHA. Då blir mappen med modellregistret vid en snabb anblick en lättläst granskningshistorik, utan att Ni behöver öppna varje fil.
from datetime import date
def model_filename(dataset, algorithm, metric_name, metric_value,
data_version='v1', ext='joblib'):
today = date.today().strftime('%Y%m%d')
metric_str = f'{metric_name}{int(metric_value * 100)}'
return f'{dataset}__{algorithm}__{today}__dv{data_version}__{metric_str}.{ext}'
# Examples
print(model_filename('titanic', 'rf', 'acc', 0.834, data_version='2'))
print(model_filename('fraud', 'xgb', 'auc', 0.971))
print(model_filename('cancer', 'logreg', 'f1', 0.955))Den kompletterande JSON-metadatafilen
Varje modellfil bör ha en tillhörande JSON-sidofil med samma grundnamn. Sidofilen dokumenterar allt som filnamnet inte kan innehålla: biblioteksversioner, hyperparametrar, träningsmängdens storlek, testresultat för alla mätvärden, lista över egenskaper och eventuella anteckningar om träningen. Detta är det minsta användbara model card.
import json
import sklearn, sys
from datetime import datetime
def save_metadata(path, dataset, algorithm, params, metrics, features, notes=''):
meta = {
'model_path': path,
'dataset': dataset,
'algorithm': algorithm,
'hyperparameters': params,
'metrics': metrics,
'features': features,
'sklearn_version': sklearn.__version__,
'python_version': sys.version.split()[0],
'trained_at': datetime.utcnow().isoformat(),
'notes': notes
}
meta_path = path.replace('.joblib', '_metadata.json')
with open(meta_path, 'w') as f:
json.dump(meta, f, indent=2)
print('Metadata saved to:', meta_path)
return meta
# Usage example
save_metadata(
'/tmp/cancer__logreg__20260620__dv1__acc97.joblib',
dataset='breast_cancer', algorithm='LogisticRegression',
params={'C': 1.0, 'max_iter': 300},
metrics={'accuracy': 0.9789, 'roc_auc': 0.9941, 'f1': 0.9831},
features=['mean radius', 'mean texture', '... 30 total'],
notes='Trained on full UCI breast cancer dataset'
)Versionsspårning för datauppsättningar
Själva träningsdatauppsättningen måste också versionshanteras. En modell som tränats på data_v1.csv och en annan som tränats på data_v2.csv ska aldrig ha samma modellidentifierare. Alternativ för versionshantering av datauppsättningar är att spara en Git SHA för datafilen, registrera en MD5-/SHA256-hash för CSV-filen eller använda ett verktyg för datahantering, till exempel DVC (Data Version Control), som hanterar datauppsättningens ursprung på samma sätt som Git hanterar kod.
import hashlib
def file_hash(path, algo='sha256'):
h = hashlib.new(algo)
with open(path, 'rb') as f:
for chunk in iter(lambda: f.read(65536), b''):
h.update(chunk)
return h.hexdigest()[:12] # first 12 hex chars as short ID
# Example: hash the model file itself as a unique ID
model_path = '/tmp/cancer_model.joblib'
model_hash = file_hash(model_path)
print('Model hash (short):', model_hash)Semantisk versionshantering för modeller
Hämta inspiration från programvaruutveckling: använd semantisk versionshantering (MAJOR.MINOR.PATCH) för modeller. MAJOR: en brytande förändring (en annan uppsättning egenskaper eller ett inkompatibelt schema). MINOR: en prestandaförbättring med samma API. PATCH: en felkorrigering eller mindre omkalibrering. Den här konventionen hjälper efterföljande användare att förstå konsekvenserna av att uppdatera sitt beroende till modellen.
model_registry = [
{'version': '1.0.0', 'algorithm': 'LogisticRegression', 'auc': 0.921,
'note': 'Initial production model'},
{'version': '1.1.0', 'algorithm': 'LogisticRegression', 'auc': 0.935,
'note': 'Retrained on 3 months more data'},
{'version': '2.0.0', 'algorithm': 'XGBoost', 'auc': 0.971,
'note': 'New algorithm; feature set changed — incompatible schema'}
]
print('Model Registry:')
for entry in model_registry:
print(f" v{entry['version']} AUC={entry['auc']} {entry['note']}")Ett enkelt lokalt modellregister
Ett enkelt modellregister kan bestå av en katalog med en registry.json-fil som indexerar alla sparade modeller. Varje post innehåller filnamn, version, viktiga mätvärden och produktionsflaggan. Distributionsskriptet läser den här filen för att avgöra vilken modell som ska laddas.
import json
import os
REGISTRY_PATH = '/tmp/model_registry.json'
def register_model(filename, version, metrics, is_production=False):
try:
with open(REGISTRY_PATH) as f:
registry = json.load(f)
except FileNotFoundError:
registry = []
# Mark all as not-production if this one is production
if is_production:
for entry in registry:
entry['is_production'] = False
registry.append({
'filename': filename,
'version': version,
'metrics': metrics,
'is_production': is_production
})
with open(REGISTRY_PATH, 'w') as f:
json.dump(registry, f, indent=2)
print(f'Registered v{version} (production={is_production})')
register_model('cancer__logreg__v1.0.0.joblib', '1.0.0',
{'accuracy': 0.979, 'auc': 0.994}, is_production=True)Läsa produktionsmodellen från registret
Vid inferens laddar tjänsten registret och hittar modellen som är markerad som produktionsmodell, varefter just den filen laddas. På så sätt frikopplas distributionsskriptet från hårdkodade filnamn — att uppdatera produktionsmodellen kräver endast att registerflaggan uppdateras, inte att serveringskoden ändras.
import json
import joblib
def load_production_model(registry_path, model_dir='/tmp'):
with open(registry_path) as f:
registry = json.load(f)
prod = next((r for r in registry if r['is_production']), None)
if prod is None:
raise RuntimeError('No production model registered!')
path = f'{model_dir}/{prod["filename"]}'
print(f'Loading production model: {prod["filename"]} (v{prod["version"]})')
print(f'Metrics: {prod["metrics"]}')
# return joblib.load(path) # would load for real
return None # demo
load_production_model('/tmp/model_registry.json')MLflow: professionellt modellregister
MLflow är branschstandardverktyget för experimentuppföljning och modellregister. Det loggar parametrar, mätvärden och artefakter för varje träningskörning, låter Er jämföra körningar via ett användargränssnitt och tillhandahåller ett modellregister med tillstånden staging, production och archived. För team ersätter MLflow manuella JSON-register med en robust backend som kan ställas frågor mot.
import mlflow
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = load_iris(return_X_y=True)
with mlflow.start_run(run_name='logreg_iris_v1'):
model = LogisticRegression(C=1.0, max_iter=200)
cv_score = cross_val_score(model, X, y, cv=5).mean()
mlflow.log_param('C', 1.0)
mlflow.log_param('max_iter', 200)
mlflow.log_metric('cv_accuracy', cv_score)
model.fit(X, y)
mlflow.sklearn.log_model(model, 'model')
print(f'CV Accuracy: {cv_score:.4f}')
print('Run logged to MLflow')Tagga modellversioner
Taggar lägger till fritt formulerade nyckel-värde-anteckningar för en modellversion — användbart för att registrera experimentets sammanhang, analytikerns namn, uppgiftstyp eller om modellen har klarat en rättvisegranskning. Det går att ställa frågor mot taggarna, vilket gör det enkelt att filtrera registret efter valfritt attribut.
# Simulated registry entry with tags (no MLflow required)
model_entry = {
'version': '2.1.0',
'filename': 'fraud__xgb__2.1.0.joblib',
'tags': {
'analyst': 'data-science-team',
'task': 'binary-classification',
'fairness_audit': 'passed',
'retrain_trigger': 'monthly-schedule',
'deployment_region': 'eu-west-1'
},
'metrics': {'roc_auc': 0.971, 'precision': 0.83, 'recall': 0.79}
}
print('Model entry:')
print(json.dumps(model_entry, indent=2))Automatiserade kriterier för befordran
Definiera tydliga kriterier för befordran innan någon modell tas i produktion: den nya modellen måste uppnå minst X % förbättring av AUC, klara en rättvisegranskning, inte försämras för någon övervakad demografisk delgrupp och slutföra inferens inom Y millisekunder. När dessa kriterier kodas, i stället för att bara dokumenteras, kan en CI/CD-pipeline automatisera besluten om befordran på ett objektivt sätt.
def should_promote(new_metrics, baseline_metrics, min_auc_improvement=0.005):
if new_metrics['auc'] < baseline_metrics['auc'] + min_auc_improvement:
return False, 'AUC improvement too small'
if new_metrics.get('fairness_delta', 0) > 0.05:
return False, 'Fairness constraint violated'
if new_metrics.get('latency_ms', 0) > 100:
return False, 'Latency too high'
return True, 'All criteria met'
baseline = {'auc': 0.921}
candidate = {'auc': 0.937, 'fairness_delta': 0.02, 'latency_ms': 45}
promote, reason = should_promote(candidate, baseline)
print(f'Promote: {promote} — {reason}')Model cards och dokumentation
Utöver tekniska metadata dokumenterar ett model card (ett begrepp som myntades av Google) modellens avsedda användning, begränsningar, egenskaper hos träningsdata, prestanda för demografiska undergrupper och etiska överväganden. För modeller som fattar beslut med stora konsekvenser, till exempel beslut om lån eller medicinsk triage, håller model cards på att bli ett regulatoriskt krav. Ta åtminstone med: avsedd användning, användningsområden utanför omfattningen, prestandamätvärden och kända fellägen.
Snabbkontroll
Testa Era kunskaper om modellversionshantering och metadata från den här lektionen.
Sammanfattning av lektionen
I den här lektionen lärde Ni Er att: beskrivande filnamn som innehåller datauppsättning, algoritm, datum och mätvärde gör modellkatalogen självbeskrivande, kompletterande JSON-metadatafiler registrerar biblioteksversioner, hyperparametrar och mätvärden som behövs för styrning och reproducerbarhet, och att ett modellregister (lokalt JSON-register eller MLflow) frikopplar serveringskoden från hårdkodade filnamn. Nästa steg är att bädda in en sparad modell i en FastAPI-slutpunkt för att tillhandahålla förutsägelser via HTTP.
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
Vanliga frågor
Är lektionen ”Versionshantera modeller: Varför filnamn och metadata spelar roll” gratis?
Ja – hela texten till ”Versionshantera modeller: Varför filnamn och metadata spelar roll” 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 ”Versionshantera modeller: Varför filnamn och metadata spelar roll”?
Ni kommer att utforma en namnkonvention som innehåller träningsdatum, datamängdsversion och metriktal samt skriva en JSON-sidofil med metadata för styrning. 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 2 av 4.
Hur lång tid tar lektionen ”Versionshantera modeller: Varför filnamn och metadata spelar roll”?
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
- Spara modeller med joblib och pickle
- Versionshantera modeller: Varför filnamn och metadata spelar roll
- Servera prediktioner med en FastAPI-endpoint
- Övervaka prediktioner: Logga indata och utdata