model_versioning

Implementa un sistema de versionado de modelos de machine learning para el pipeline de verificación de identidad, permitiendo registrar, almacenar y gestionar múltiples versiones de cada modelo (ArcFace, MiniFASNet, YOLOv8). Soporta rollback instantáneo y despliegue de nuevas versiones sin interrumpir el servicio de verificación en producción.

When to use

Usa esta skill cuando necesites gestionar el ciclo de vida de versiones de modelos ML dentro del modelserveragent. Aplica cuando se entrene o fine-tunee un nuevo modelo de face recognition o liveness detection y se requiera desplegarlo de forma controlada, o cuando sea necesario revertir a una versión anterior por degradación de métricas.

Instructions

1. Definir el esquema de registro de modelos con metadata obligatoria:

```python from dataclasses import dataclass from datetime import datetime

@dataclass class ModelVersion: modelname: str # ej: "arcface", "minifasnet", "yolov8doc" version: str # semver: "1.2.0" artifactpath: str # ruta al archivo del modelo format: str # "onnx", "torchscript", "mar" metrics: dict # {"far": 0.0008, "frr": 0.032, "latencyp95ms": 45} trainingdataset: str # referencia al dataset de entrenamiento createdat: datetime status: str # "staging", "production", "archived", "rolledback" ```

1. Implementar el registro de modelos en PostgreSQL para persistencia y auditoría:

```python class ModelRegistry: def register(self, model: ModelVersion) -> str: """Registra una nueva versión y retorna el versionid.""" model.status = "staging" self.db.insert(model) self.uploadartifact(model.artifactpath, model.version) return model.version

def promote(self, modelname: str, version: str): """Promueve un modelo de staging a production.""" currentprod = self.getproductionversion(modelname) if currentprod: self.updatestatus(currentprod, "archived") self.update_status(version, "production") ```

1. Almacenar los artefactos de modelo en MinIO (S3-compatible) con versionado habilitado:

``python def uploadartifact(self, localpath: str, version: str): self.minioclient.fputobject( bucketname="model-artifacts", objectname=f"{modelname}/{version}/model.onnx", filepath=localpath, metadata={"version": version, "format": "onnx"} ) ``

1. Implementar rollback instantáneo recargando la versión anterior sin reiniciar el servidor:

``python def rollback(self, modelname: str): """Revierte al último modelo en producción archivado.""" previous = self.db.query( "SELECT * FROM modelversions WHERE modelname=? AND status='archived' ORDER BY createdat DESC LIMIT 1", modelname ) self.updatestatus(previous.version, "production") self.updatestatus(self.getproductionversion(modelname), "rolledback") self.modelserver.hotreload(modelname, previous.artifact_path) ``

1. Validar automáticamente cada nueva versión contra un dataset de validación antes de permitir la promoción a producción:

``python def validatebeforepromote(self, modelname: str, version: str) -> bool: modelpath = self.getartifactpath(modelname, version) metrics = self.evaluator.evaluate(modelpath, self.validation_dataset) return metrics["far"] < 0.001 and metrics["frr"] < 0.05 ``

1. Exponer endpoints de gestión para listar versiones, promover y hacer rollback desde la Management API del model server.

1. Configurar alertas automáticas que disparen rollback si las métricas de producción (FAR/FRR) degradan por encima de los umbrales definidos.

Notes

• Nunca eliminar artefactos de versiones anteriores inmediatamente; mantener al menos las 3 últimas versiones disponibles para rollback rápido en caso de degradación post-despliegue.
• La validación automática (paso 5) es un gate obligatorio antes de promover cualquier modelo a producción; esto previene que modelos con FAR/FRR fuera de umbral lleguen a servir verificaciones reales.
• El hot-reload de modelos debe ser atómico: las solicitudes en vuelo deben completarse con la versión anterior mientras las nuevas solicitudes usan la versión actualizada.