9 · Estaciones · DatosLección 2 de 2
Versionado y linaje
Versioning and lineage
Cómo se congela el dataset de cada mes en un manifest que nadie puede pisar, cómo se ata a cada modelo y cómo se contesta, meses después, con qué datos se entrenó y en qué modelos está una foto.
Secciones14
- 01Qué entra y qué sale de la estación
- 02El manifest y la tarjeta
- 03Que nadie lo pise
- 04Labels como eventos y split estable
- 05Cuatro formas de versionar extra
- 06Linaje y reproducibilidad
- 07El pipeline mensual como DAG
- 08Borrar sin romper la historia extra
- 09Errores comunes
- 10En la vida real extra
- 11Ejercicios
- 12Lo que sigue
- 13Palabras que vas a oír
- 14Chequeo
El modelo de octubre de Alba se entrenó con casi dos millones de fotos etiquetadas. ¿Cómo guardas exactamente ese conjunto sin copiar 400 GB cada mes, cómo te aseguras de que nadie lo cambie y cómo contestas dentro de un año con qué datos salió ese modelo?
Alba, la empresa que seguimos en todo el curso, es un marketplace en línea: recibe ≈ 2.5 millones de publicaciones nuevas al día, con ≈ 3 fotos cada una, y sugiere la categoría de cada foto entre 500. Lo hace con un modelo de visión, una red ResNet-50, que corre en la nube de Amazon (AWS). El modelo se vuelve a entrenar cada mes con las etiquetas nuevas. El dataset de septiembre, el conjunto de fotos con su etiqueta, tiene 1,932,628 fotos: 1,840,211 para entrenar (el train, con el que el modelo aprende) y 92,417 para validar (la validación, que se guarda aparte para medirlo).
Ahora imagina tres preguntas que llegan meses después. Un analista: «¿con qué datos exactos se entrenó el modelo de octubre?». Una ingeniera, al ver que el modelo nuevo es peor: «¿cambió el código o cambiaron los datos?». Y legal: «Ana pidió borrar sus datos; ¿en qué datasets y en qué modelos están sus fotos?».
Las tres son preguntas de datos, y ninguna se contesta con Git. Git guarda cada versión del código; pero el código de entrenamiento de octubre y el de noviembre pueden ser idénticos y dar modelos distintos, porque cambiaron los datos. Si nadie congeló los datos de octubre, no hay manera de volver a ellos.
Esta lección es el paso del sistema de Alba que hace ese trabajo. Las piezas ya las conoces. El snapshot, de «Object storage, data lakes y warehouses», es una versión fija de los datos de un momento, que ya no cambia. El commit, de «Git: versiones del código», es una versión guardada del código, con un id corto como c3f2fc2. La huella SHA-256, de «Tiempo, hashes e identificadores», es un resumen de 64 caracteres que se calcula con los bytes de un archivo: el mismo archivo da siempre la misma huella, y si cambia un solo byte, la huella es otra por completo.
Qué entra y qué sale de la estación
EsencialWhat goes in and what comes out
El versionado de datos es guardar cada versión de un dataset de modo que se pueda volver a leer exactamente igual, con un nombre que no cambia. Es lo mismo que Git hace con el código, pero con millones de archivos que no caben en Git.
Lo que entra
El paso anterior del sistema (la lección «Datos y etiquetas») le entrega a este una sola cosa:
- Los labels del mes. Un label (etiqueta) es la categoría correcta de una foto, la respuesta que el modelo debe aprender. Llegan de dos lados: ≈ 5,000 fotos revisadas por personas, y los labels «débiles», que salen de lo que hace la gente: lo que eligió quien vende, si pasaron 30 días sin que el equipo de moderación de Alba, que revisa publicaciones, lo corrigiera, y las correcciones de moderación. Llegan como eventos: una fila nueva por label, con su autor, su hora y su fuente.
Y consulta dos cosas que no cambian cada mes:
- El golden set
golden-v3: 50,000 fotos etiquetadas por dos personas, con cada desacuerdo adjudicado por moderación, y congelado. Sirve para medir; nunca entra al entrenamiento. - La guía de etiquetado con su versión (
guia-v4en noviembre de 2026): las reglas escritas que dicen qué categoría lleva cada caso dudoso. Cada label dice con qué versión de la guía se hizo.
Lo que sale
Sale un snapshot: una versión congelada del dataset, con nombre propio. Lleva la fecha del primer día del mes que cubre, y lo arma la corrida del día 1 del mes siguiente, cuando ese mes ya terminó. El de septiembre se llama ds-2026-09-01, y lo arma la corrida del 1 de octubre con los labels que existían a las 00:00 UTC de ese día (la hora de referencia mundial, sin horario de verano).
Vive en S3, el object storage de AWS: un almacén donde cada archivo es un objeto que se guarda y se pide por su llave, su nombre completo. La dirección es s3://ml-datos/datasets/ds-2026-09-01/: el bucket (el almacén con nombre propio donde viven los objetos) se llama ml-datos, y datasets/ds-2026-09-01/ es un prefijo, el principio común de las llaves de ese snapshot, que funciona como una carpeta. Ahí hay tres archivos:
rows.parquet: el manifest, una fila por foto. Es el snapshot en sí.snapshot.json: la tarjeta, que dice de dónde salió el manifest y su huella.validation.json: el reporte de los chequeos que pasó antes de publicarse.
Ojo: de ≈ 75 millones de publicaciones al mes, Alba no entrena con todas. El snapshot es el conjunto acumulado: todos los labels humanos (≈ 406 mil, 21 %), todas las correcciones de moderación (≈ 135 mil, 7 %) y una muestra de ≈ 1.39 millones de labels maduros de quien vende (72 %), con tope por categoría y por vendedor. Los «labels del mes» son lo que se agrega o se renueva ese mes.
Las fotos no se copian. Siguen donde ya estaban, en el almacenamiento del producto (el bucket donde la app guarda las fotos que sube la gente), y el manifest las cita por su llave y su huella.
Lo que decide
Este paso toma cinco decisiones, y cada una tiene su sección:
- Qué guarda el snapshot y cómo se describe: el manifest y la tarjeta.
- Cómo se impide que alguien lo pise: la escritura condicional y la publicación al final.
- Cómo se reparten las fotos entre train y validación sin que se muevan de un mes a otro: el split estable.
- Con qué herramienta se versiona: prefijos inmutables, DVC, lakeFS o una tabla con time travel (una tabla que deja leer cómo estaba en una fecha pasada).
- Qué apunta a qué: del modelo al snapshot, al commit y a cada foto. Eso es el linaje.
- Labels del mes · tabla de eventos
Cada label es un evento que nunca se edita, con su fuente, su autor, su hora y la versión de la guía (labels como eventos). Aquí llegan las ≈ 5,000 fotos del mes revisadas por personas y los labels débiles filtrados. - Validar · contrato de datos
Los chequeos de entrada del contrato de datos: esquema exacto (las columnas y sus tipos),label_identre 0 y 499, horas en UTC y datos al día: lo más nuevo tiene menos de 48 h. Si algo rompe, se detiene antes de gastar nada. - Armar el manifest · corte · split · huellas
Toma, para cada foto, el label más reciente que ya existía a la hora del corte (point-in-time correctness); una elección de quien vende solo cuenta si ya pasaron 30 días sin corrección. Reparte por hash delseller_id(mod 100 < 95 → train), quita duplicados por huella y escribe una fila por foto con su SHA-256. - golden-v3 · 50,000 fotos · aparte
El golden set congelado. Nunca entra al entrenamiento: sus huellas se cruzan contra el manifest, y si aparece una, se detiene. - Auditar · validation.json
Los chequeos sobre el snapshot ya armado: ninguna foto en dos splits, ninguna del golden, volumen entre 0.8 y 1.5 veces el del padre, labels débiles en 80 % o menos. El resultado queda envalidation.json. - Prefijo temporal · staging/ds-2026-09-01/
Donde se escribe primero: ningún entrenamiento busca aquí. Es el «escribir» de escribir, auditar, publicar. - Fine-tune · lee la tarjeta primero
El entrenamiento solo acepta un snapshot con tarjeta, y comprueba surows_sha256y la huella de cada foto al leer. - Publicar · datasets/ds-2026-09-01/
Se subenrows.parquetyvalidation.jsonal prefijo definitivo con PUT y escritura condicional: la política del bucket rechaza cualquier PUT sinIf-None-Match: *, y Alba no copia dentro de S3: la guía de AWS dice que la copia falla, aunque desde octubre de 2025CopyObjectacepta el header. - Tarjeta · snapshot.json, al final
Lo último que se escribe. Un snapshot sin tarjeta no existe: si el job se cae antes, queda un manifest huérfano que nadie lee.
El principio que ordena todo es corto: un snapshot se escribe una vez y nunca se edita; un cambio es otro snapshot. Si en octubre aparece un error en una etiqueta de septiembre, no se corrige ds-2026-09-01: la corrección entra a ds-2026-10-01. Así, quien lea ds-2026-09-01 dentro de un año lee lo mismo que leyó el entrenamiento.
El manifest y la tarjeta
EsencialThe manifest and the card
Una fila por foto
Un manifest (en español también se dice manifiesto) es un archivo que lista los elementos de un conjunto, cada uno con lo necesario para encontrarlo y comprobarlo. El de Alba es un archivo Parquet, el formato de «Archivos y formatos» que guarda cada columna junta y comprimida. Tiene una fila por foto y estas columnas:
| Columna | Qué guarda | Ejemplo |
|---|---|---|
image_key | la llave de la foto en el almacenamiento del producto | fotos/2026/08/02/a01.jpg |
image_sha256 | la huella SHA-256 de los bytes de la foto | 64 caracteres hexadecimales (0–9 y a–f) |
seller_id | quién la publicó (decide el split) | s-104 (un id de juguete) |
label_id | la categoría, de 0 a 499 | 17 |
label_source | de dónde salió el label | humano, moderador o vendedor_filtrado |
guia_version | la guía con que se etiquetó | guia-v4 |
split | a qué parte va | train o val |
width, height | el tamaño de la foto, en píxeles | 1200, 900 |
created_at | cuándo se publicó, en UTC | 2026-08-02T14:31:07Z |
¿Para qué la huella, si ya está la llave? Porque la llave es un nombre, y un nombre puede apuntar a otra cosa mañana. Si alguien sube otra foto a la misma llave, la llave sigue igual pero la huella ya no coincide. Al leer, el entrenamiento recalcula el SHA-256 de cada foto y lo compara con el del manifest: si no coincide, la foto cambió, y el paso se detiene.
La huella del manifest entero
El manifest también tiene su huella: el SHA-256 de todo el archivo rows.parquet. Se llama rows_sha256, se escribe en la tarjeta y cada modelo la guarda. Si alguien cambiara una sola etiqueta de las 1,932,628, la huella sería otra.
El programa de abajo arma un manifest de juguete con 10 fotos y calcula su huella. Para que la huella no dependa del orden en que llegaron las filas, las ordena antes. Usa CSV (texto con comas) en vez de Parquet para no instalar nada, recorta las huellas a pocos caracteres para que se lean y usa ids de juguete, como s-104, para quien vende.
import csv, hashlib, io
filas = [ # image_key, image_sha256 (corto), seller_id, label_id, label_source, split
("fotos/2026/08/02/a01.jpg", "9b1e", "s-104", 17, "humano", "train"),
("fotos/2026/08/02/a02.jpg", "4c7d", "s-104", 17, "vendedor_filtrado", "train"),
("fotos/2026/08/03/b11.jpg", "e2a0", "s-309", 233, "moderador", "val"),
("fotos/2026/08/04/c31.jpg", "71f5", "s-318", 233, "vendedor_filtrado", "train"),
("fotos/2026/08/05/d07.jpg", "0d93", "s-407", 90, "humano", "train"),
("fotos/2026/08/06/e12.jpg", "a4b8", "s-512", 412, "vendedor_filtrado", "train"),
("fotos/2026/08/07/f44.jpg", "5e2c", "s-512", 412, "vendedor_filtrado", "train"),
("fotos/2026/08/08/g09.jpg", "c81a", "s-633", 5, "vendedor_filtrado", "train"),
("fotos/2026/08/09/h20.jpg", "38f6", "s-441", 90, "humano", "val"),
("fotos/2026/08/10/i15.jpg", "d1c4", "s-805", 17, "vendedor_filtrado", "train"),
]
def huella(rows):
buf = io.StringIO()
csv.writer(buf).writerows(sorted(rows)) # mismo orden siempre
datos = buf.getvalue().encode()
return hashlib.sha256(datos).hexdigest()[:12], len(datos)
h, n_bytes = huella(filas)
print("rows_sha256:", h, "·", n_bytes, "bytes ·", round(n_bytes / len(filas)), "B por fila")
otra = list(filas)
otra[3] = otra[3][:3] + (234,) + otra[3][4:] # una sola etiqueta cambia
print("una etiqueta distinta:", huella(otra)[0])
print("mismas filas, otro orden:", huella(list(reversed(filas)))[0])rows_sha256: 9c3ec1ab181a · 598 bytes · 60 B por fila
una etiqueta distinta: 4fab4aa4f20b
mismas filas, otro orden: 9c3ec1ab181aUna etiqueta de diez cambió y la huella es otra por completo; el mismo contenido en otro orden da la misma. Aquí cada fila mide ≈ 60 B porque las huellas están recortadas. Con las 10 columnas reales y las huellas completas de 64 caracteres, el equipo de Alba estima ≈ 200 B por fila.
Cuánto pesa y cuánto ahorra
En «Archivos y formatos» viste que un manifest pesa ≈ 0.1 % de las fotos que cita. Aquí lo ponemos en dólares y con Parquet. Lo que hace barato este diseño es que el manifest cita y no copia. Las dos primeras ecuaciones dicen cuánto pesa cada cosa; las dos últimas, cuánto cuesta guardar un año de snapshots citando las fotos o copiándolas:
- donde
- N
- filas del manifest, una por foto
- r
- bytes que ocupa cada fila del manifest, sin comprimir, en B
- f
- bytes que ocupa cada foto, en B
- M
- bytes del manifest, sin comprimir, en B
- F
- bytes de las fotos que el manifest cita, en B
- z
- cuántas veces comprime Parquet el manifest; lo guardado pesa M÷
z - k
- cuántos snapshots se guardan, uno por mes
- c
- lo que cuesta guardar un GB durante un mes, en US$ (los bytes se pasan a GB antes de multiplicar)
- costocitar
- lo que cuesta al mes guardar los k manifests, en US$
- costocopiar
- lo que costaría al mes guardar una copia de las fotos por cada snapshot, en US$
La fracción M÷
Hay un precio escondido: un snapshot que cita depende de que las fotos sigan ahí. Si el producto borra una foto, la fila del manifest apunta a nada. Por eso el entrenamiento comprueba cada huella al leer, y por eso, cuando la foto se borra a propósito, el borrado se anota (lo ves en la sección «Borrar sin romper la historia»).
Aplica las cuatro ecuaciones de la lección (M=
Cuenta solo el almacenamiento en S3 Standard, a US$0.023 por GB al mes (precio de lista de us-east-1, noviembre de 2026), sin el cobro por cada petición ni copias en otra región. El ≈ 4 de Parquet es un estimado del equipo de Alba con compresión zstd: cada huella SHA-256 no baja de sus 32 B; con la compresión más ligera (snappy) el manifest pesaría casi el doble.
Empieza con el snapshot de septiembre. Sube r a 400 B (más columnas): el manifest se duplica, pero sigue siendo una fracción mínima de las fotos. Luego sube los snapshots guardados a 60 (cinco años): citar sigue costando centavos; copiar, cientos de dólares al mes.
La tarjeta: de dónde salió
El manifest dice qué hay. La tarjeta, snapshot.json, dice de dónde salió y cómo comprobarlo. Es un archivo JSON chico: texto con pares «nombre: valor», fácil de leer para un programa y para una persona. Este es el de septiembre; la huella está recortada y el resto es ilustración de cómo se ve:
{
"snapshot_id": "ds-2026-09-01",
"parent": "ds-2026-08-01",
"created_at": "2026-10-01T03:12:44Z",
"rows_path": "s3://ml-datos/datasets/ds-2026-09-01/rows.parquet",
"rows_sha256": "5d1f…e7a2",
"counts": { "train": 1840211, "val": 92417, "total": 1932628 },
"label_sources": { "humano": 0.21, "moderador": 0.07, "vendedor_filtrado": 0.72 },
"split": { "by": "seller_id", "rule": "hash mod 100 < 95 -> train" },
"code": { "repo": "ml-catalogo", "commit": "4be1d0a" },
"validation": { "status": "passed",
"report": "s3://ml-datos/datasets/ds-2026-09-01/validation.json" }
}Cada campo contesta una pregunta. parent dice cuál era el snapshot anterior: contra él se compara el volumen antes de publicar. label_sources dice la mezcla que viste arriba: 72 % de quien vende, 7 % de moderación, 21 % a mano. code dice qué código armó el snapshot: el commit 4be1d0a del repositorio ml-catalogo (la carpeta de código que Git versiona). Ojo: ese no es el código que entrena. El modelo guarda su propio commit, c3f2fc2 en el ejemplo. Son dos programas distintos, y cada artefacto apunta al suyo.
Además de la tarjeta, que leen las máquinas, se escribe una ficha del dataset para personas: qué hay, de dónde salió, cómo se etiquetó, cómo se dividió y, sobre todo, para qué no sirve. La de Alba dice, por ejemplo, que el 72 % de labels de quien vende no sirve para medir el modelo: quien vende muchas veces acepta la categoría que el modelo le sugirió, así que medir con esos labels es comparar al modelo consigo mismo. Para medir está el golden set. La idea viene de un artículo de 2018 que propuso las datasheets for datasets, como las hojas de datos que acompañan a una pieza electrónica.
Que nadie lo pise
EsencialNobody overwrites it
Inmutable por diseño, no por acuerdo
La inmutabilidad (de un snapshot) de un snapshot quiere decir que, una vez escrito, nadie puede cambiarlo: ni borrarlo, ni reemplazar un archivo, ni agregarle filas. Sin eso, todo lo anterior es una promesa. El modelo de octubre dice «me entrené con ds-2026-09-01», y si alguien reescribió ese prefijo en noviembre, el puntero miente.
Lo peligroso no es un ataque: es un descuido. Un script que corre dos veces. Una persona que «arregla» una etiqueta en el snapshot viejo porque es más rápido que esperar al siguiente. Un job (un programa que corre una tarea y termina) que escribe en datasets/ds-2026-09-01/ porque alguien copió mal una fecha. En object storage eso no da error. Para guardar un objeto se manda un PUT, el método de HTTP que dice «guarda esto con esta llave»; y un PUT a una llave que existe reemplaza el objeto entero, en silencio. Gana el último.
Por eso Alba no confía en que la gente tenga cuidado. Usa tres defensas, cada una para un hueco distinto.
Defensa 1: la escritura condicional
Una escritura condicional es un PUT que solo se cumple si se cumple una condición. Ya la viste en «Object storage, data lakes y warehouses»; aquí la usa un snapshot. Desde agosto de 2024, S3 acepta el header If-None-Match: * (un header es una línea de datos extra que viaja con la petición), que quiere decir «guarda esto solo si no hay nada con esa llave». Si la llave ya existe, S3 responde con el código 412 (Precondition Failed, «la condición previa no se cumplió») y no toca nada.
Pero un header lo pone quien escribe: un script que no lo pone escribe igual. Para que deje de ser opcional, la regla va en la política del bucket (bucket policy): un documento JSON, pegado al bucket, con reglas de quién puede hacer qué, y que S3 aplica a todos sin excepción. La de Alba dice dos cosas sobre el prefijo datasets/: niega cualquier PUT que no traiga el header, y niega borrar. Con eso, un snapshot nuevo se escribe sin problema, y uno viejo no se puede pisar ni borrar para volverlo a escribir.
Con la copia hay que tener cuidado. La guía de AWS todavía avisa que, con una política así, una copia (CopyObject) hacia el prefijo falla, aunque desde octubre de 2025 CopyObject acepta el mismo header. Como AWS se contradice, Alba no se apoya en la copia: el snapshot se publica subiendo los archivos con PUT.
Para ir más hondoCómo se escribe la regla+
Esta es una ilustración de la parte que niega el PUT sin header, sin correrla:
{
"Sid": "SnapshotsSoloNuevos",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::ml-datos/datasets/*",
"Condition": {
"Null": { "s3:if-none-match": "true" },
"Bool": { "s3:ObjectCreationOperation": "true" }
}
}Se lee así: «niega (Deny) a cualquiera (Principal: *) guardar objetos (s3:PutObject) en datasets/ si el header If-None-Match es nulo, es decir, si no viene». Resource es el nombre completo, en el formato de AWS (un ARN), de las llaves a las que aplica: todas las de datasets/ en el bucket ml-datos.
La segunda condición limita la regla a las operaciones que crean el objeto. Un archivo grande se sube en pedazos, y los pedazos no llevan el header; solo el paso final, el que los junta, lo lleva. Sin esa condición, la regla bloquearía cada pedazo.
La otra mitad es otra regla igual, con Deny sobre s3:DeleteObject en el mismo prefijo (y sobre s3:DeleteObjectVersion, si el bucket guarda versiones): sin ella, alguien podría borrar el snapshot y escribirlo de nuevo, porque la llave ya estaría vacía.
Defensa 2: versiones y Object Lock, y lo que no protegen
Ya las viste en «Object storage, data lakes y warehouses»; aquí, qué protegen y qué no. S3 puede guardar versiones: con el versionado del bucket (S3 Versioning) prendido, un PUT a una llave que existe no destruye el objeto viejo; lo guarda como versión anterior, con su propio id. Y Object Lock va más lejos: cada versión queda bloqueada durante un plazo, y nadie la puede borrar, ni siquiera quien administra la cuenta, si se usa el modo más estricto.
Suena a la solución, pero tiene un hueco: Object Lock protege cada versión, no la llave. Un PUT a la misma llave sigue funcionando: crea otra versión, y esa pasa a ser la que se lee. La vieja sigue ahí, intacta, pero el entrenamiento que pide rows.parquet sin decir qué versión recibe la nueva. La escritura condicional cierra ese hueco; las versiones sirven para recuperar lo que se borró por error.
PUT a una llave que ya existe. Sin protección, se reemplaza en silencio. Con versiones u Object Lock, la vieja sobrevive, pero la que se lee es la nueva. Con la escritura condicional, S3 responde 412 y no cambia nada.Defensa 3: la huella
Si las dos defensas fallaran (una política mal escrita, un permiso de más), queda la última: el modelo guarda rows_sha256. Antes de usar un snapshot, cualquiera recalcula la huella de rows.parquet y la compara con la del modelo. Si no coincide, el snapshot cambió, y se sabe. No impide nada, pero delata. Es la misma idea que fijar con hash una dependencia en «Ataques y cadena de suministro»: anotar la huella exacta de una biblioteca que se descarga, para notar si alguien la cambió.
Escribir, auditar, publicar
Queda un último riesgo: un snapshot a medias. El job escribe rows.parquet y se cae antes de escribir validation.json. ¿Existe el snapshot o no? Si el siguiente entrenamiento lo encuentra, entrena con algo que nadie revisó.
La salida es un patrón que se llama escribir, auditar, publicar (write-audit-publish):
- 1
Escribir aparte
El job escribe el manifest en un prefijo temporal,
s3://ml-datos/staging/ds-2026-09-01/, donde nadie lo busca. - 2
Auditar
Corren los chequeos del contrato de datos, las reglas que los datos cumplen antes de entrenar, sobre el manifest ya armado: ninguna foto en dos splits, ninguna huella del golden set, volumen entre 0.8 y 1.5 veces el del snapshot padre, labels débiles en 80 % o menos. Antes de armar ya pasaron los de los labels del mes (esquema exacto,
label_identre 0 y 499, horas en UTC, frescura), y al armar se aplicaron el corte, la regla de 30 días y los duplicados por huella. El resultado va avalidation.json. - 3
Publicar o detenerse
Si todo pasa, se suben con
PUTel manifest y el reporte adatasets/ds-2026-09-01/, y al final la tarjeta, todo con escritura condicional (no se copian dentro de S3, por lo que viste en la defensa 1). Si algo falla, no se publica nada: el entrenamiento de ese mes no corre y sigue el modelo actual.
La tarjeta es la última en escribirse a propósito: un snapshot sin tarjeta no existe. Quien entrena lee siempre la tarjeta primero; si no está, no hay snapshot, aunque haya un rows.parquet huérfano en el prefijo. Así, la escritura completa pasa o no pasa, como en una transacción de base de datos (un grupo de cambios que se aplica completo o no se aplica), aunque S3 no tenga transacciones.
Labels como eventos y split estable
EsencialLabels as events and a stable split
Un label no se corrige: se agrega otro
Imagina que el 25 de junio quien vende pone «Calzado › Tenis». Pasan más de 30 días sin que moderación lo corrija, así que el snapshot de julio, que se arma el 1 de agosto, lo trae como label, y el modelo de agosto aprende «Tenis». El 10 de agosto moderación lo corrige a «Calzado › Botas». Si la tabla de labels guarda una fila por foto y la corrección la reescribe, ya no sabes qué label había el 1 de agosto, y no puedes explicar por qué el modelo de agosto aprendió «Tenis».
Alba guarda los labels como eventos: cada label es una fila nueva que nunca se edita, con la foto, el label, quién lo puso (la fuente), con qué versión de la guía y a qué hora. Corregir es agregar otro evento, más nuevo, que reemplaza al anterior. Nada se pierde.
Con eso, un snapshot es una consulta: «para cada foto, el label más reciente que ya existía a tal hora». Al armarlo se aplican el corte y la regla de 30 días: una elección de quien vende solo cuenta si ya maduró. Es el point-in-time de «Tiempo, hashes e identificadores», aplicado a los labels: el snapshot de septiembre, con corte a las 00:00 UTC del 1 de octubre, no puede ver un label que llegó el 4 de octubre.
import hashlib
eventos = [ # (image_sha256, label_id, fuente, guia_version, hora UTC del evento)
("3a90", 17, "vendedor", "guia-v3", "2026-08-02T10:00Z"),
("3a90", 18, "moderador", "guia-v3", "2026-08-20T16:30Z"), # corrige: reemplaza al anterior
("b7e1", 233, "vendedor", "guia-v3", "2026-08-27T09:12Z"),
("b7e1", 230, "humano", "guia-v4", "2026-10-04T11:05Z"), # llega después del corte
("f02c", 233, "vendedor", "guia-v3", "2026-08-28T12:40Z"),
]
def vigentes(eventos, corte):
ultimo = {}
for img, label, fuente, guia, hora in sorted(eventos, key=lambda e: e[4]):
if hora < corte: # point-in-time: solo lo que ya existía
ultimo[img] = (label, fuente, guia)
return ultimo
print("corte 1 oct:", vigentes(eventos, "2026-10-01T00:00Z"))
print("corte 1 nov, b7e1:", vigentes(eventos, "2026-11-01T00:00Z")["b7e1"])
def split(seller_id, u=95):
cubeta = int(hashlib.sha256(seller_id.encode()).hexdigest(), 16) % 100
return cubeta, "train" if cubeta < u else "val"
for s in ["s-104", "s-309", "s-318", "s-441"]:
print(s, *split(s))
print("s-309 otra vez:", *split("s-309"))corte 1 oct: {'3a90': (18, 'moderador', 'guia-v3'), 'b7e1': (233, 'vendedor', 'guia-v3'), 'f02c': (233, 'vendedor', 'guia-v3')}
corte 1 nov, b7e1: (230, 'humano', 'guia-v4')
s-104 87 train
s-309 95 val
s-318 46 train
s-441 99 val
s-309 otra vez: 95 valEl corte del 1 de octubre, el de ds-2026-09-01, ve la corrección de agosto, pero no el label humano del 4 de octubre; el del 1 de noviembre, el de ds-2026-10-01, sí. Los dos snapshots son correctos, cada uno para su fecha. El juguete no aplica la regla de 30 días de quien vende: sus elecciones del 27 y 28 de agosto ya la cumplen el 1 de octubre. (Las horas se comparan como texto porque todas van en ISO 8601 y en UTC: del año al minuto, así que el orden del texto es el del tiempo.)
El split: por vendedor y con hash
En «Datos, ejemplos, features y etiquetas» viste por qué Alba reparte por vendedor y no por foto: si las fotos de un mismo vendedor cayeran en train y en validación, el modelo reconocería «la mesa de este vendedor» y validación saldría mejor de lo que es. Ahora falta que el reparto sea el mismo cada mes.
- donde
- H
- la función hash SHA-256, leída como un número entero
- seller_id
- el id de quien vende, como texto
- cubeta
- el residuo de dividir ese número entre 100, de 0 a 99
- u
- el umbral de cubeta; en Alba, 95: el 95 % de los vendedores va a train
La función hash da siempre el mismo número para el mismo texto (lo viste como asignación con hash). Por eso el vendedor s-309 cae en la cubeta 95 hoy, el mes que entra y dentro de diez años: siempre en validación. Un vendedor nuevo cae donde le toque, sin mover a nadie.
Split estable: que nada de validación se mueva
Un split estable es un reparto en el que cada foto cae en train o en validación una vez y se queda ahí en todas las versiones. Las fotos nuevas se reparten sin mover las viejas. La regla de Alba lo dice sin matices: ninguna foto de validación de ds-2026-09-01 puede estar en train en ds-2026-10-01.
¿Qué pasa si no? Imagina que cada mes se sortea el split otra vez, al azar, con 95 % a train. Cada foto de validación de septiembre tiene 95 % de probabilidad de caer en train en el snapshot de octubre.
- donde
- V
- fotos de validación del snapshot viejo
- u
- el umbral de cubeta, 95, que aquí funciona como el porcentaje a train
- Y
- fotos de esa validación que el sorteo nuevo manda a train, en promedio
- T
- meses en que se sortea otra vez
- W
- fracción de todas las fotos que estuvo en validación por lo menos uno de esos meses, de 0 a 1
ds-2026-09-01Aplica las ecuaciones de la lección, Y=
Supone que cada sorteo es independiente y que las fotos viejas siguen en el dataset. El sorteo es por foto; si fuera por vendedor, la fracción sería la misma, pero se moverían vendedores enteros.
Empieza con la validación de septiembre y un año de sorteos. Baja u a 80: se mueven menos fotos por mes, pero en un año casi todas pasaron por validación. Con el split por hash, el número que se mueve es siempre cero.
El golden set tiene su propia regla, más dura: nunca entra al entrenamiento. Con el manifest ya armado, antes de publicarlo, se cruzan sus huellas SHA-256 contra las 50,000 de golden-v3; si aparece una, el paso se detiene. Cuando el golden set se refresca, no se edita: se crea golden-v4, y se vuelve a medir al modelo actual con él.
Cuatro formas de versionar
ExtraFour ways to version data
Lo de las secciones anteriores es una forma de versionar. Hay otras, y conviene saber cuándo cada una es la buena.
1. Prefijos inmutables y manifest
Es lo que hace Alba: un prefijo por versión (datasets/ds-2026-09-01/), un manifest en Parquet, una tarjeta y una política del bucket que impide pisar. No hay que instalar nada: es S3, un formato de archivo y unas reglas. Funciona muy bien cuando el dataset son muchos archivos que no cambian (fotos) y lo que cambia por versión es qué fotos entran y con qué label.
2. DVC: Git para los datos
DVC (Data Version Control) es una herramienta de código abierto que se usa junto con Git. Para cada archivo o carpeta de datos calcula una huella y la guarda en un archivo chiquito, de texto, que sí va a Git; los datos de verdad suben a un almacén aparte, como un bucket de S3. Hacer git checkout de un commit viejo (volver el código a como estaba en ese commit) y luego dvc checkout devuelve también los datos de ese commit. Es la misma idea que Git LFS, que guarda en Git solo un puntero a cada archivo grande, pero pensada para datasets y con pasos de pipeline.
Es cómodo para equipos chicos y datasets de hasta cientos de miles de archivos. Con millones de archivos chicos, calcular y comparar todas las huellas se vuelve lento.
3. lakeFS: ramas sobre el bucket
lakeFS pone encima de un bucket lo que Git pone encima de una carpeta: ramas (branches, líneas de trabajo paralelas), commits y merges (juntar una rama con otra), sin copiar los datos. Crear una rama de un dataset de 400 GB tarda lo mismo que crear una de 1 KB, porque no se copia nada: la rama nueva apunta al mismo commit, y solo lo que se escriba después en ella es distinto. Su uso estrella es escribir, auditar, publicar: el job escribe en una rama, unos chequeos (hooks) corren antes del merge, y el merge a main publica todo de golpe. Desde la versión 1.87.0 (22 de septiembre de 2026) su licencia, el documento que dice qué se permite hacer con el programa, es la BSL 1.1, ya no Apache 2.0 (una licencia abierta que deja hacer casi todo): se puede usar sin pagar dentro de la empresa, en producción, siempre que no se modifique, pero no ofrecerlo como servicio a gente de fuera. Antes de adoptarlo, alguien tiene que leer el texto de la licencia.
4. Tablas con time travel
Un formato de tabla, como Delta Lake o Apache Iceberg, convierte un montón de archivos Parquet en una tabla con transacciones: un registro aparte dice qué archivos forman cada versión. Lo viste en «Object storage, data lakes y warehouses» como la pieza del lakehouse: archivos baratos en un bucket que se consultan como si fueran una base de datos. Con ese registro se puede leer la tabla como estaba en una versión o una fecha: el time travel.
Es la buena opción cuando los datos son tablas que cambian fila por fila: transacciones, precios, features de clientes. Ahí no hay «fotos que no cambian»: hay filas que se corrigen y se borran todos los días.
| Prefijos + manifest | DVC | lakeFS | Delta / Iceberg | |
|---|---|---|---|---|
| Qué versiona | listas de archivos | archivos y carpetas | todo un bucket | tablas |
| Dónde vive la versión | un prefijo y su tarjeta | un archivo chico en Git | un commit de lakeFS | el registro de la tabla |
| Ramas para probar | no | las de Git | sí, sin copiar | Iceberg sí (ramas y tags); Delta no |
| Hay que operar | nada | casi nada | un servidor y su base | un motor de consultas que lo lea (Spark, Trino…) |
| Lo malo | sin la política, convención | lento con millones de archivos | otro sistema que mantener | la retención borra el pasado |
| Le conviene a | fotos que no cambian | equipos chicos | equipos grandes con muchos jobs | datos tabulares que cambian |
¿Y Alba? Su equipo de ML es de 5 personas y su dataset son fotos que no cambian, citadas por huella. Prefijos con manifest le bastan, y no tiene que operar nada nuevo. Si el equipo creciera y varias personas armaran datasets a la vez, lakeFS le daría ramas para que cada quien pruebe sin pisar a los demás. Si sus datos fueran tablas que cambian, como las features (los datos de entrada del modelo) de un sistema de fraude, usaría Iceberg o Delta.
Para ir más hondoCómo se protege una versión que tiene que durar+
Una versión de tabla se puede volver reproducible solo si se marca aparte. La regla es una desigualdad:
- donde
- E
- la edad de la versión, en días: cuántos días pasaron desde que se escribió
- L
- la retención de esa versión, en días: cuánto la guarda la herramienta antes de que la limpieza la borre
Un modelo que se entrenó con la tabla al 1 de septiembre de 2026 y se revisa el 15 de diciembre: E = 105 días (la cuenta está en el ejercicio de abajo). Con L = 30 días de Delta (o 7, si corre VACUUM), E>
La salida es un tag con su propia retención: un nombre fijo que se le pone a una versión, como un tag de Git (aquí no es la etiqueta de una foto). En Iceberg, con Spark SQL (el lenguaje de consultas de Spark, un motor para datos grandes), se ve así (ilustración):
ALTER TABLE ventas CREATE TAG septiembre RETAIN 365 DAYS
y después se lee con SELECT … FROM ventas VERSION AS OF 'septiembre'. Ahora L = 365 para esa versión, y la limpieza no la toca. Lo mismo que el prefijo inmutable de Alba, pero dentro de la tabla. La retención de cada tag se decide pensando en cuánto vive el modelo y cuánto pide legal, no en lo que trae la herramienta por omisión.
Delta no tiene tags. Ahí hay dos salidas: subir la retención de toda la tabla (delta.logRetentionDuration y delta.deletedFileRetentionDuration), y pagar por guardar todos los archivos viejos de ese plazo, o copiar aparte la versión que usó el modelo.
Para practicar esta sección, con lápiz:
- 1Fácil
¿Qué forma de versionar elegirías en cada caso: (a) 2 personas con 30,000 fotos de un proyecto de la escuela; (b) un equipo de 40 personas con decenas de jobs que escriben al mismo lake; (c) una tabla de transacciones de tarjeta que se corrige todos los días; (d) Alba?
Ver la solución paso a paso
- (a) DVC: el dataset cabe y el equipo ya usa Git.
- (b) lakeFS: cada job escribe en su rama y se publica con un merge después de los chequeos.
- (c) Iceberg o Delta, guardando cada versión que use un modelo: con un tag de retención larga en Iceberg, o con una retención larga en la tabla o una copia en Delta.
- (d) Prefijos inmutables con manifest: fotos que no cambian, equipo de 5, nada que operar.
- 2Medio
Un sistema de fraude guarda sus features en una tabla Delta con la retención por omisión (30 días de historial; 7 para los archivos, si corre
VACUUM). Su modelo se entrenó con la tabla al 1 de septiembre de 2026, y el 15 de diciembre una auditoría pide repetir el entrenamiento. ¿Se puede? ¿Qué debió hacer el equipo, y hasta qué fecha alcanzaría?Ver la solución paso a paso
- La regla: se puede releer si E≤
L . La edad de esa versión el 15 de diciembre es E = 29 (lo que queda de septiembre después del día 1) + 31 + 30 + 15 = 105 días. Con L = 30 (o 7), E>L : no se puede; la limpieza ya pudo borrarla. - Delta no tiene tags. Al entrenar, debió subir la retención de la tabla (
delta.logRetentionDurationydelta.deletedFileRetentionDuration), por ejemplo a 365 días, o copiar aparte esa versión. Con L = 365, se puede releer hasta el 1 de septiembre de 2027.
- La regla: se puede releer si E≤
Linaje y reproducibilidad
EsencialLineage and reproducibility
Tres punteros y un poco más
El linaje (lineage) es la cadena de qué salió de qué: este modelo salió de este snapshot, armado por este código, con fotos que tienen estas huellas. Se guarda como punteros, no como copias.
Cada modelo que Alba registra guarda tres punteros:
- El snapshot: su id,
ds-2026-09-01, y su huella,rows_sha256. - El commit del código de entrenamiento:
c3f2fc2en el ejemplo. - El digest de la imagen de entrenamiento. Aquí «imagen» no es una foto: es la imagen de un contenedor, el paquete que trae el programa con todo lo que necesita para correr, con las versiones exactas de Python, PyTorch y CUDA. Su digest es su huella SHA-256: dice exactamente qué paquete corrió.
Y además, junto a los pesos: labels.json, el archivo que traduce cada label_id a su nombre («17 → Calzado › Tenis»), con su huella, y la versión del preprocesamiento (cómo se achica y se normaliza cada foto antes de entrar al modelo). Si alguien cambiara el orden de las categorías sin cambiar los pesos, el modelo diría «Tenis» cuando quiere decir «Botas»; la huella de labels.json lo delata.
Todos viven en el registro de modelos, que en Alba es MLflow; lo ves a fondo en «Gate de evaluación y registry». Aquí importa qué guarda, no la herramienta.
Ojo con los nombres: el snapshot se llama por el mes que cubre, y el modelo, por el día en que se entrena. La corrida del 1 de octubre arma ds-2026-09-01, el snapshot de septiembre, y ese mismo día entrena con él resnet50-2026-10-01. El modelo pasa el gate (la evaluación que decide si es mejor que el actual), recibe uno o dos días copias del tráfico y luego una parte creciente del real, y en la primera semana de octubre ya atiende todo. Por eso resnet50-2026-10-01 ← ds-2026-09-01, y resnet50-2026-11-01 ← ds-2026-10-01.
- Respuesta · model_version
Cada respuesta del servicio y cada línea del log llevanmodel_version: resnet50-2026-10-01. Es la punta del hilo: el nombre del modelo que contestó. - Modelo registrado · resnet50-2026-10-01
En el registro de modelos, la versión guarda tres punteros (snapshot, commit, digest) ylabels.json. No copia nada: apunta. - labels.json · id → categoría, con huella
Traduce cadalabel_ida su nombre. Su huella va con el modelo: si alguien cambia el orden de las categorías, se nota. - Commit c3f2fc2 · código que entrenó
El commit del código de entrenamiento, con el árbol limpio: el pipeline clona ese commit y nada más. - Tarjeta del snapshot · ds-2026-09-01 · rows_sha256
El modelo guarda el id y la huella del manifest. Antes de usarlo, se recalcula la huella: si no coincide, el snapshot cambió. - Imagen de entrenamiento · fijada por su digest
No es una foto: es la imagen de un contenedor, el paquete con el entorno exacto (Python, PyTorch y CUDA) donde corrió el entrenamiento, identificada por su digest, su huella SHA-256. - Commit 4be1d0a · código que armó el snapshot
Otro programa, otro commit: el que armó el snapshot, en el repositorioml-catalogo. Lo dice la tarjeta encode. - Manifest · rows.parquet · 1,932,628 filas
Una fila por foto, con su llave, su huella SHA-256, su label, su fuente, la versión de la guía y su split. - Una foto de Ana · llave + SHA-256
Vive en el almacenamiento del producto; el manifest la cita. Al leerla, el entrenamiento comprueba que su huella sea la del manifest. - Registro de borrados · huellas, fecha, motivo
Una lista de solo agregar. Los snapshots viejos no se reescriben: el entrenamiento salta las filas cuya huella está aquí.
Contestar las tres preguntas
Con los punteros, las tres preguntas del principio son mecánicas:
- «¿Con qué datos se entrenó el modelo de octubre?» El registro dice
ds-2026-09-01y su huella. Se lee la tarjeta, se comprueba la huella, se abre el manifest: 1,932,628 filas, cada una con su foto y su label. - «¿Cambió el código o los datos?» Se comparan los punteros de los dos modelos. Si el commit es el mismo y el snapshot no, cambiaron los datos; si es al revés, el código. Si cambiaron los dos, se repite uno con el otro fijo.
- «¿En qué modelos está la foto de Ana?» Se busca su huella en la columna
image_sha256de los manifests, y cada snapshot que la tiene apunta a los modelos que lo usaron.
Sin linaje, cada una de esas preguntas es una semana de arqueología: revisar notebooks, preguntar quién corrió qué, adivinar.
Reproducibilidad: cinco ingredientes
La reproducibilidad es poder volver a entrenar un modelo y obtener el mismo resultado. Un entrenamiento tiene cinco ingredientes, y cada uno se fija con su puntero:
| Ingrediente | Qué es | Cómo lo fija Alba |
|---|---|---|
| Código | el programa de entrenamiento | el commit, con el árbol limpio |
| Datos | qué fotos y con qué label | el snapshot y su rows_sha256 |
| Configuración | la receta: learning rate 3e-4 (0.0003), batch de 64 fotos, 8 épocas (pasadas por todos los datos) | un archivo en el repositorio, en el mismo commit |
| Entorno | Python, PyTorch, CUDA y los drivers de la GPU | el digest de la imagen de entrenamiento |
| Aleatoriedad | el orden de las fotos, las variaciones al azar | la semilla, 17: el número con que arranca el azar del programa |
Uno que falla mucho: «el árbol limpio». Un commit dice qué código había guardado; si el script tenía cambios sin commit cuando corrió, el puntero apunta a otro código. Por eso Alba no entrena desde la laptop de nadie: entrena desde el pipeline, que descarga una copia limpia del repositorio (lo clona) en ese commit y nada más.
Mismo resultado, ¿qué tan mismo?
Aun con los cinco ingredientes fijos, en una GPU dos corridas casi nunca dan los mismos bits: algunas sumas se hacen en paralelo y en otro orden, y en números con decimales el orden cambia el último dígito (determinismo tiene la historia; «Entrenamiento y experimentos» la cuenta a fondo). Por eso hay tres niveles de «igual»:
- Bit a bit: los mismos pesos (los números que el modelo aprendió), byte por byte. Caro y frágil en GPU.
- Dentro de tolerancia: las métricas se parecen tanto como se parecen dos corridas con distinta semilla. Es el nivel de Alba.
- Estadístico: el mismo comportamiento en promedio, sobre muchas corridas.
¿Cuánto es «tolerancia»? Alba mide la exactitud (accuracy) en el golden set: qué porcentaje de las fotos clasifica bien. Las diferencias se cuentan en puntos: de 85.2 % a 85.3 % hay 0.1 puntos (porcentuales). Su regla: una repetición del modelo de octubre, que sacó 85.23 %, «se reprodujo» si queda a 0.26 puntos o menos, hacia arriba o hacia abajo. Si se va más lejos, algo de los cinco ingredientes cambió, y se busca cuál. El bloque de abajo dice de dónde sale el 0.26.
Para ir más hondoDe dónde sale la tolerancia: cinco semillas+
Para saber cuánta tolerancia, Alba entrenó la misma receta con 5 semillas distintas y midió la exactitud de cada una en el golden set. La dispersión se mide con la desviación estándar:
- donde
- s
- cuántas corridas, cada una con otra semilla
- xi
- la exactitud de la corrida i en el golden set, en %
- x̄
- el promedio de las s corridas, en %
- σ
- la desviación estándar de las corridas, en puntos porcentuales
- τ
- la tolerancia de Alba para decir «se reprodujo», en puntos: tres desviaciones
Compáralo con otra regla. Medir en el golden set también tiene margen de error: 50,000 fotos son una muestra, no todas las fotos. Es el intervalo de confianza de «Ruido, muestras y pruebas A/B»: ε=
import math, statistics
semillas = [85.21, 85.34, 85.12, 85.29, 85.18] # exactitud top-1 en el golden, en %
media = statistics.mean(semillas)
sigma = statistics.stdev(semillas) # desviación estándar de la muestra
tau = 3 * sigma # tolerancia de Alba para repetir
print(f"media {media:.2f} % · sigma {sigma:.3f} · tolerancia {tau:.2f} puntos")
a, G = 0.85, 50_000 # exactitud y fotos del golden
margen = 1.96 * math.sqrt(a * (1 - a) / G) * 100 # ε, el margen del 95 %, en puntos
print(f"margen del golden ± {margen:.2f} puntos")
for repetida in (85.41, 85.71): # dos intentos de repetir la de 85.23
delta = repetida - 85.23
print(f"{repetida}: {delta:+.2f} ->", "se reprodujo" if abs(delta) <= tau else "algo cambió")media 85.23 % · sigma 0.088 · tolerancia 0.26 puntos
margen del golden ± 0.31 puntos
85.41: +0.18 -> se reprodujo
85.71: +0.48 -> algo cambióEl pipeline mensual como DAG
EsencialThe monthly pipeline as a DAG
Quién arma el snapshot cada mes
Nadie en Alba arma el snapshot a mano. Lo arma un programa que corre solo el día 1 de cada mes, a las 03:00 UTC, con los datos del mes que acaba de terminar. Ese programa es un orquestador de pipelines: decide cuándo corre cada paso y en qué orden, reintenta el que falla, guarda qué entró y qué salió de cada uno y avisa si algo se rompe. No procesa datos: los procesan los pasos.
Ojo con la palabra: la orquestación de Kubernetes (lección «Kubernetes») es otra cosa. Kubernetes es el sistema que, en Alba, arranca los contenedores en un grupo de máquinas; su orquestación es mantener vivos los contenedores de un servicio. Un orquestador de pipelines corre tareas que empiezan y terminan.
Alba usa Argo Workflows, que corre en su mismo cluster de Kubernetes, ese grupo de máquinas: cada paso es un contenedor que arranca, hace su tarea y termina. Un CronWorkflow lo dispara el día 1 a las 03:00 UTC; si un paso falla, avisa a la persona de guardia. Otros orquestadores muy usados son Airflow, Dagster y Kubeflow Pipelines; la idea es la misma.
El DAG: pasos y flechas
Un pipeline se describe como un DAG (directed acyclic graph, grafo dirigido acíclico): pasos unidos por flechas que dicen «este va después de aquel», sin ciclos, porque un paso no puede esperar a uno que lo espera a él. El de Alba tiene 8 pasos, 4 de ellos con GPU en dos tipos de tarjeta (el fine-tune y evaluar, en una A10G; el engine y la paridad, en una T4):
validar datos → armar snapshot → fine-tune (GPU) → evaluar (GPU) → gate → construir el engine en una T4 (GPU) → paridad (GPU) → registrar
El fine-tune ajusta a las 500 categorías de Alba, con el snapshot nuevo, una ResNet-50 que ya viene entrenada con millones de fotos genéricas. El gate decide si el modelo nuevo es mejor que el actual. El engine es el modelo convertido para correr rápido en la GPU de producción, una NVIDIA T4. La paridad comprueba que el engine responda lo mismo que el modelo original. Cada uno tiene su lección; aquí importa el orden.
Cada paso recibe sus entradas de forma explícita: el snapshot por su id, el código por su commit, la receta como parámetros. Así el orquestador puede guardar el linaje de cada corrida sin que nadie lo escriba.
En Argo, la corrida del 1 de octubre recibe su fecha como parámetro; el paso que arma el snapshot calcula con ella el mes anterior y arma ds-2026-09-01; y el fine-tune recibe ese id como salida del paso anterior. Un paso nunca pregunta «¿cuál es el más nuevo?».
Para ir más hondoCómo se declara en Argo+
Una ilustración de cómo se declara (un pedazo, simplificado; Argo usa YAML, un formato de texto que marca qué va dentro de qué con la sangría):
apiVersion: argoproj.io/v1alpha1
kind: CronWorkflow
metadata: { name: reentreno-mensual }
spec:
schedules: ["0 3 1 * *"] # minuto 0, hora 3, día 1, cualquier mes
timezone: "UTC"
workflowSpec:
entrypoint: mensual
templates:
- name: mensual
dag:
tasks:
- { name: validar, template: validar }
- name: snapshot # la corrida del 2026-10-01 arma ds-2026-09-01
template: armar
dependencies: [validar]
arguments:
parameters:
- name: corrida
value: "{{workflow.creationTimestamp.Y}}-{{workflow.creationTimestamp.m}}-01"
- name: fine-tune
template: entrenar
dependencies: [snapshot]
arguments:
parameters:
- name: snapshot # el id que armó el paso anterior
value: "{{tasks.snapshot.outputs.parameters.id}}"
- { name: evaluar, template: evaluar, dependencies: [fine-tune] }Fíjate en dependencies: eso son las flechas del DAG. Los parámetros hacen lo que viste arriba: la fecha de la corrida entra, y el id del snapshot pasa de un paso al siguiente.
La caché y la trampa de latest
Un orquestador puede guardar la salida de cada paso y reusarla si el paso vuelve a correr con las mismas entradas: es la caché de pasos. Si el fine-tune ya corrió con este código, esta receta y este snapshot, ¿para qué gastar otras 3–4 horas de GPU? En Argo se llama memoization, se prende por paso y la llave la escribe quien define el paso, casi siempre con sus parámetros; en Kubeflow Pipelines viene prendida y el orquestador arma la llave solo.
- donde
- llave
- lo que el orquestador busca entre las salidas guardadas
- H
- la función hash, la misma del split
- código
- el código del paso, por su commit
- parámetros
- la receta y los demás parámetros, escritos como texto
- entradas
- las entradas como las recibe el paso: rutas o ids, no lo que hay guardado en ellas
Cuando una entrada llega como una ruta de texto, el orquestador no mira qué hay dentro: hashea cómo se llama. Si una entrada se llama datasets/latest y el contenido de esa carpeta cambió, el nombre no cambió, la llave es la misma, y el orquestador reusa la salida vieja.
import hashlib, json
cache = {} # llave -> salida guardada del paso
def fine_tune(codigo, params, entrada, corrida):
llave = hashlib.sha256(json.dumps([codigo, params, entrada]).encode()).hexdigest()[:10]
if llave in cache:
return f"{corrida}: llave {llave} -> reusa {cache[llave]}"
cache[llave] = f"modelo entrenado con lo que había en '{entrada}' el {corrida}"
return f"{corrida}: llave {llave} -> entrena"
receta = {"lr": 3e-4, "epocas": 8, "batch": 64, "semilla": 17}
print(fine_tune("c3f2fc2", receta, "datasets/latest", "1 oct"))
print(fine_tune("c3f2fc2", receta, "datasets/latest", "1 nov")) # la carpeta ya cambió
print(fine_tune("c3f2fc2", receta, "ds-2026-09-01", "1 oct"))
print(fine_tune("c3f2fc2", receta, "ds-2026-10-01", "1 nov"))1 oct: llave 10d32e075f -> entrena
1 nov: llave 10d32e075f -> reusa modelo entrenado con lo que había en 'datasets/latest' el 1 oct
1 oct: llave 4dec1a924f -> entrena
1 nov: llave 7262ec1bc5 -> entrenaCon latest, la corrida de noviembre «entrena» en cero segundos y registra un modelo nuevo que es el de octubre. Nadie se entera: el pipeline sale verde. Con el id del snapshot como parámetro, cada mes tiene su llave. La regla: toda entrada que cambia el resultado tiene que ser un parámetro o un artefacto con nombre fijo, nunca una carpeta que cambia de contenido.
latest, la llave de noviembre es igual a la de octubre y se reusa el modelo viejo. Con el id del snapshot, la llave cambia y el paso corre.Tres propiedades de un buen paso
Para que el orquestador pueda reintentar y repetir sin miedo, cada paso que procesa datos cumple tres cosas:
- Particionado: trabaja sobre un pedazo con nombre, como un día (la carpeta
dt=2026-09-28, dondedtes la fecha) o un snapshot, no sobre «todo». - Idempotente: correrlo dos veces deja lo mismo que correrlo una (idempotencia, de «Timeouts, reintentos e idempotencia»). Reescribe su partición entera; no agrega filas al final.
- Backfillable: la fecha llega como parámetro, nunca la lee del reloj con
now(), la función que devuelve la hora actual. Así se puede correr para el pasado, que es un backfill: recalcular fechas viejas.
La tercera tiene una trampa doble. Un paso que usa now() no se puede repetir para septiembre; y una feature (un dato de entrada del modelo) calculada con now() en vez de con la hora del ejemplo mira el futuro: usa información que en ese momento todavía no existía. Eso es leakage.
Para ir más hondoCuánto tarda un backfill, y por qué se le pone tope+
Un backfill recorre muchas particiones. Si cada una tarda lo mismo, la cuenta es:
- donde
- P
- particiones que hay que recalcular, por ejemplo días
- j
- cuántas corren a la vez
- d
- minutos que tarda cada partición
- D
- minutos que tarda todo; ⌈ ⌉ redondea hacia arriba, porque la última tanda cuenta entera
Borrar sin romper la historia
ExtraDeleting without breaking history
Inmutable no quiere decir eterno. Una persona tiene derecho a pedir que borren sus datos (derecho al borrado, de «Datos personales y la ley»), y un snapshot que nadie puede tocar parece chocar con eso. No choca, si se diseña.
Ana pide borrar
El 20 de octubre de 2026, Ana, una vendedora de Ciudad de México, pide que borren sus datos. Sus fotos viejas están en ds-2026-09-01, el snapshot con que se entrenó el modelo que está en producción.
Los pasos generales los cuenta «Datos personales y la ley» (derecho al borrado): encontrar cada copia, borrarla, decidir qué pasa con el modelo y dejar constancia. Aquí, lo que agrega el linaje:
- 1
Encontrar con las huellas
Con las huellas SHA-256 de las fotos de Ana se consulta la columna
image_sha256de todos los manifests, del golden set y de las fotos que salieron a etiquetar (labeled/): aparecen ends-2026-09-01y en los snapshots anteriores que las traigan. El de octubre todavía no existe: se arma el 1 de noviembre. - 2
Anotar, no reescribir
El producto borra las fotos originales, pero los snapshots viejos no se tocan. Sus huellas entran a un registro de borrados, una lista de solo agregar con la huella, la fecha y el motivo. El snapshot siguiente,
ds-2026-10-01, ya no las incluye. - 3
Los modelos
resnet50-2026-10-01, en producción, tiene a Ana y sirve hasta que lo reemplazaresnet50-2026-11-01, entrenado conds-2026-10-01, que ya no la trae.
No confundas dos registros: el de auditoría, de esa lección, es la constancia de que se borró, qué y cuándo; el de borrados es la lista de huellas que lee el pipeline, para que cada entrenamiento respete el borrado.
Por qué no reescribir
¿No sería más fácil reescribir ds-2026-09-01 sin las fotos de Ana? Se rompería todo lo que apunta a él: la huella de resnet50-2026-10-01 ya no coincidiría, y no habría forma de saber si cambió por un borrado legítimo o por un error. Anotar deja la historia intacta y dice exactamente qué falta y por qué.
Al leer un snapshot para entrenar, el pipeline aplica el registro: se salta cada fila cuya huella esté ahí, y el modelo guarda cuántas filas saltó y hasta qué fecha leyó el registro. Ese número es parte del linaje. Si un día se quiere repetir resnet50-2026-11-01, se lee ds-2026-10-01 con el registro hasta esa fecha.
Una pregunta queda para legal, no para ingeniería: cuánto tiempo puede seguir sirviendo un modelo entrenado con datos borrados. En Alba, como mucho hasta el reemplazo mensual: para Ana, del 20 de octubre a la primera semana de noviembre, unas dos o tres semanas. Si la ley pidiera menos, se adelanta un reentrenamiento: 3–4 horas y US$10–50 en una GPU.
Errores comunes
EsencialCommon mistakes
Escribir el snapshot en una carpeta latest. Cada mes la carpeta cambia de contenido y el nombre no. Un modelo que dice «me entrené con latest» no dice nada, y la caché del pipeline reusa el resultado viejo. Cómo evitarlo: un id con fecha por snapshot, pasado como parámetro, y latest, si existe, solo como un puntero de lectura que ningún paso usa.
Creer que el versionado del bucket o Object Lock impiden pisar. Protegen cada versión, pero un PUT a la misma llave crea otra versión que pasa a ser la que se lee. Cómo evitarlo: escritura condicional exigida por la política del bucket, y comprobar rows_sha256 antes de entrenar.
Confiar en el time travel para reproducir un modelo de hace meses. La limpieza de Delta o Iceberg borra las versiones viejas: por omisión, en días o semanas. Cómo evitarlo: en Iceberg, un tag (un nombre fijo para una versión) con su propia retención por cada versión que use un modelo; en Delta, que no tiene tags, una retención más larga en la tabla o una copia de esa versión; en cualquiera, un snapshot propio con manifest.
Sortear el split otra vez en cada versión. En un mes, ≈ 87,796 de las 92,417 fotos de validación de Alba pasarían a train, y las métricas de un modelo y el siguiente dejan de ser comparables. Cómo evitarlo: split por hash del seller_id, que pone a cada vendedor siempre del mismo lado.
Corregir un label reescribiendo la fila. Se pierde qué label había antes, y un snapshot viejo ya no se puede explicar. Cómo evitarlo: labels como eventos; corregir es agregar uno nuevo.
Entrenar con cambios sin commit. El modelo guarda un commit que no es el código que corrió. Cómo evitarlo: entrenar solo desde el pipeline, que clona el commit y revisa que el árbol esté limpio.
Usar el commit del snapshot como si fuera el del modelo. 4be1d0a armó el snapshot; c3f2fc2 entrenó el modelo. Cómo evitarlo: cada artefacto guarda el commit del código que lo produjo, con un nombre de campo que diga cuál es.
En la vida real
ExtraIn real life
Alba. Una vez al mes, un CronWorkflow de Argo arma el snapshot, lo audita, lo publica con escritura condicional y entrena. Cuando algo sale raro en producción, la respuesta lleva model_version: resnet50-2026-10-01, y de ahí se llega en minutos a cada foto con que se entrenó.
Inspección en una fábrica. Un sistema de visión revisa piezas en una línea y aparta las defectuosas. Cuando un cliente reclama, la pregunta es «¿qué modelo decidía en la línea 2 el martes a las 14:00, y con qué datos se entrenó?». Con linaje se contesta en minutos. Los veredictos de quien inspecciona se guardan como eventos que no se sobrescriben, igual que los labels de Alba.
OCR de documentos con revisión humana. Un sistema que lee el texto de documentos escaneados (OCR) y los manda a revisar cuando duda tiene que poder decir, para cada decisión, qué modelo leyó, con qué dataset se entrenó, qué contenedor corría y quién revisó. Son los punteros de Alba, más el revisor, porque una auditoría externa los pide.
Recomendación. Un sistema que ordena productos para cada persona guarda, con cada lista que mostró, qué features vio el modelo en ese momento. Sin eso, no puede entrenar el siguiente modelo con lo que de verdad pasó: las features de hoy no son las de ayer.
Pronóstico de demanda. Los datos son tablas de ventas que se corrigen todos los días (devoluciones, ventas que llegan tarde). Ahí la herramienta natural es una tabla Iceberg o Delta, y cada entrenamiento nocturno fija la versión de la tabla al arrancar y la registra con el modelo.
Fuera de ML. Un laboratorio clínico guarda la muestra, el reactivo con su lote, el equipo y quién hizo el análisis. Si un lote de reactivo sale malo, sabe qué resultados revisar. Es linaje, con otro nombre: trazabilidad.
Ejercicios
EsencialExercises
Resuélvelos con lápiz antes de abrir la solución. Los del tamaño del snapshot y del split se pueden comprobar con las calculadoras.
- 1Fácil
Un equipo quiere agregar al manifest de Alba dos columnas más y calcula que cada fila pasará de ≈ 200 B a ≈ 260 B. Con las 1,932,628 filas de septiembre y fotos de ≈ 200 KB, ¿cuánto pesa el manifest sin comprimir, y qué fracción de las fotos citadas es?
Ver la solución paso a paso
- Con M=
N× : 1,932,628 × 260 B ≈ 502 MB, ≈ 0.5 GB sin comprimir.r - Fracción r÷
f = 260 ÷ 200,000 = 0.0013 = 0.13 %. Sigue siendo casi nada: no depende de cuántas fotos haya.
- Con M=
- 2Fácil
Con la regla de Alba, cubeta = H(seller_id) mod 100 y train si la cubeta es menor que u = 95, cuatro vendedores caen en las cubetas 12, 94, 95 y 99. ¿A dónde va cada uno? En la versión siguiente alguien propone u = 90 «para tener más validación». ¿Qué pasa con el split estable?
Ver la solución paso a paso
- Cubetas 12 y 94: train (menores que 95). Cubetas 95 y 99: validación.
- Con u = 90, los vendedores con cubeta de 90 a 94 pasan de train a validación. El modelo viejo se entrenó con sus fotos, así que si se mide en la validación nueva, lleva ventaja: ya vio parte del examen. El split dejó de ser estable.
- Si de verdad hace falta más validación, se agregan vendedores nuevos a validación (por ejemplo, una regla aparte para los que llegaron después de cierta fecha) sin mover a los viejos.
- 3Fácil
Una foto tiene estos eventos de label: el 3 de agosto, «Hogar › Lámparas» de quien vende; el 25 de agosto, «Hogar › Focos» de moderación; el 2 de septiembre, «Hogar › Lámparas» de la cola humana, con
guia-v4. ¿Qué label traeds-2026-08-01, el snapshot de agosto, con corte el 1 de septiembre? ¿Yds-2026-09-01, con corte el 1 de octubre?Ver la solución paso a paso
ds-2026-08-01(corte 1 de septiembre): el evento más reciente antes del corte es el del 25 de agosto: «Hogar › Focos», de moderación. El del 2 de septiembre todavía no existía.ds-2026-09-01(corte 1 de octubre): el del 2 de septiembre, «Hogar › Lámparas», de la cola humana conguia-v4.- Ninguno de los dos está mal: cada uno es correcto para su fecha. Y el snapshot de agosto no se corrige: la corrección entra al de septiembre.
- 4Medio
Un backfill tiene que recalcular 90 días de una feature; cada día tarda 15 minutos y el orquestador permite 10 a la vez. ¿Cuánto tarda en serie y cuánto con 10? Si el día 47 falla, ¿qué se repite y qué tiene que cumplir el paso?
Ver la solución paso a paso
- Con D=
⌈P/j⌉× : en serie, 90 × 15 = 1,350 min = 22.5 h. Con j = 10: ⌈90 ÷ 10⌉ × 15 = 9 × 15 = 135 min ≈ 2.3 h.d - Se repite solo el día 47. El paso tiene que ser idempotente: reescribe la partición
dt=de ese día entera, y repetirlo deja lo mismo. Y la fecha llega como parámetro, no connow().
- Con D=
- 5Medio
Para encontrar las fotos de Ana hay que leer la columna
image_sha256de los 12 manifests del último año. Cada huella ocupa ≈ 32 B ya guardada en Parquet (sus 64 caracteres hexadecimales comprimidos no bajan de sus 32 B de información). ¿Cuántos bytes se leen, si cada manifest tiene ≈ 1,932,628 filas? ¿Por qué no hay que leer los 12 × 100 MB enteros?Ver la solución paso a paso
- Bytes leídos = manifests × filas × bytes por huella. Por manifest: 1,932,628 × 32 B ≈ 61.8 MB. Los 12: 12 × 61.8 MB ≈ 742 MB.
- No se lee todo porque Parquet guarda cada columna junta: se lee solo la de las huellas, como viste en «Archivos y formatos».
- Con las huellas de Ana se sabe en qué snapshots está, y cada snapshot dice qué modelos lo usaron.
- 6Reto
La ingeniera de guardia repite el entrenamiento de
resnet50-2026-10-01y obtiene 85.71 % en el golden set, contra 85.23 % del original. La tolerancia de Alba es τ=3× , con σ ≈ 0.088 puntos. ¿Se reprodujo? Si no, ¿en qué orden revisarías los cinco ingredientes y qué comparas en cada uno?σ Ver la solución paso a paso
- τ = 3 × 0.088 ≈ 0.26 puntos. La diferencia es 85.71 − 85.23 = 0.48 puntos > 0.26: no se reprodujo. Algo cambió.
- Primero los datos: ¿la tarjeta que leyó tiene el mismo
rows_sha256? ¿Aplicó el mismo registro de borrados? Un snapshot distinto es la causa más común y la más fácil de ver. - Luego el código y la configuración: el mismo commit, y que el árbol estuviera limpio en la corrida original.
- Luego el entorno: el mismo digest de la imagen de entrenamiento, y la misma clase de GPU.
- Al final la aleatoriedad: la semilla 17. Si todo coincide, corre 5 semillas: si la nueva cae dentro de la nube de las otras, el original fue la rara.
- 7Reto
El pipeline de Alba sale verde el 1 de noviembre, pero el modelo nuevo da exactamente las mismas métricas que el de octubre, a la centésima. ¿Qué sospechas? ¿Cómo lo confirmas con la tarjeta y la caché, y qué cambias para que no vuelva a pasar?
Ver la solución paso a paso
- Que el fine-tune no corrió: la caché reusó la salida de octubre porque su llave no cambió. Pasa si una entrada se llama igual cada mes, como
datasets/latest. - Se confirma en el historial del orquestador (el paso aparece como reusado, en segundos y no en horas) y en el registro: el modelo de noviembre apunta a la misma
rows_sha256que el de octubre. - Arreglo: el id del snapshot entra como parámetro (
ds-2026-10-01en la corrida de noviembre), así que la llave cambia cada mes. Y un chequeo antes de registrar: si la huella del snapshot es igual a la del modelo anterior, se detiene.
- Que el fine-tune no corrió: la caché reusó la salida de octubre porque su llave no cambió. Pasa si una entrada se llama igual cada mes, como
- 8Reto
Diseña el versionado de un sistema de búsqueda por foto: cada mes se recalculan los vectores (embeddings: listas de números que resumen cada foto) de ≈ 100 millones de publicaciones activas con un modelo nuevo, y el índice, la estructura que encuentra rápido los vectores parecidos, se reconstruye. Los números son un supuesto del ejercicio. Di qué guarda el snapshot, qué punteros guarda cada índice y qué pasa si una persona pide borrar una publicación.
Ver la solución paso a paso
- El snapshot: un manifest con la llave y la huella de cada foto que entró al índice, la versión del modelo que hizo los vectores, y la fecha de corte de qué publicaciones estaban activas. Los vectores mismos sí se guardan (no se pueden «citar»), en un prefijo inmutable por versión.
- Cada índice guarda: el id del snapshot y su huella, el modelo de los vectores, el commit del código que construyó el índice y el digest de su imagen.
- Un borrado: la publicación sale del índice en vivo de inmediato (la búsqueda no puede devolverla). El snapshot viejo no se reescribe: la huella entra al registro de borrados, y el índice del mes siguiente ya no la trae.
Lo que sigue
EsencialWhat comes next
- «Entrenamiento y experimentos» toma el snapshot de esta lección como entrada fija: corre el fine-tune, guarda cada corrida con sus parámetros y métricas, y cuenta por qué en una GPU la misma semilla no da los mismos bits.
- «Gate de evaluación y registry» decide si el modelo nuevo es mejor que el actual con el golden set, y registra la versión con los punteros que viste aquí.
- «Empaquetado con Docker» explica la imagen de contenedor y su digest, el tercer puntero.
- «Monitoreo, drift y reentrenamiento» cuenta cuándo se adelanta el reentrenamiento mensual y qué snapshot usa cuando pasa.
Palabras que vas a oír
EsencialWords you will hear
Estos son los conceptos que presentó esta lección. Cada uno tiene su tarjeta con la definición completa.
Versionado de datosdata versioningGuardar cada versión de un dataset con un nombre que no cambia, de modo que se pueda volver a leer exactamente igual meses después. Git lo hace con el código; los datos no se versionan solos.Más +
Un modelo depende de su código y de sus datos. Git guarda cada versión del código, pero no sirve para millones de fotos. El versionado de datos congela cada dataset en un snapshot con un id (como ds-2026-09-01), lo protege para que nadie lo cambie (inmutabilidad (de un snapshot)) y deja que cada modelo apunte a él (linaje). Hay cuatro formas comunes: prefijos inmutables con un manifest, DVC, lakeFS y tablas con time travel. Sin versionado, «¿con qué datos se entrenó este modelo?» no tiene respuesta.
Ejemplo. Alba arma un snapshot cada mes, el día 1, con el mes que acaba de terminar: la corrida del 1 de octubre arma ds-2026-09-01, con 1,932,628 fotos etiquetadas. Si en octubre se corrige una etiqueta, no se toca el de septiembre: la corrección entra a ds-2026-10-01, que se arma el 1 de noviembre.
ManifestmanifestUn archivo que lista los elementos de un conjunto, cada uno con lo necesario para encontrarlo y comprobarlo. Un snapshot de fotos es un manifest: una fila por foto con su llave (su nombre en el almacén) y su huella SHA-256 (un resumen de sus bytes que cambia si cambia la foto).Más +
En machine learning, el manifest es la forma barata de versionar archivos grandes: en vez de copiar cada foto, se guarda una lista que la cita por su llave en el object storage y por su huella SHA-256. La huella detecta si la foto cambió o desapareció. El manifest mismo tiene su huella (en Alba, rows_sha256), que guarda cada modelo: si alguien cambia una fila, la huella ya no coincide. Pesa una fracción mínima de lo que cita: bytes por fila ÷ bytes por foto.
Analogía. El índice de una biblioteca: no tiene los libros, dice dónde está cada uno y cuál es su edición. Donde se rompe: si alguien se lleva un libro, el índice no lo impide; solo deja ver que falta.
Ejemplo. El manifest de ds-2026-09-01 es un Parquet (un formato de archivo para tablas) con 1,932,628 filas y 10 columnas (image_key, image_sha256, seller_id, label_id, label_source…). Pesa ≈ 400 MB sin comprimir y ≈ 100 MB en Parquet; las fotos que cita, ≈ 400 GB.
Inmutabilidad (de un snapshot)immutabilityQue algo, una vez escrito, ya no se pueda cambiar: ni borrar, ni reemplazar, ni agregarle nada. Un cambio es una versión nueva con otro nombre.Más +
Un snapshot solo sirve si es inmutable: el modelo dice «me entrené con este», y si alguien lo reescribe después, el puntero miente. En object storage, un PUT (la petición que guarda un archivo) a una llave que existe reemplaza el objeto en silencio, así que la inmutabilidad hay que imponerla: con la escritura condicional exigida por la política del bucket, con permisos que no dejan borrar, y con la huella del manifest para detectar si algo cambió. Inmutable no es eterno: cuando hay que borrar datos de una persona, se anota el borrado en vez de reescribir.
Ejemplo. s3://ml-datos/datasets/ds-2026-09-01/ se escribe una vez, el 1 de octubre de 2026. Un error encontrado en octubre se corrige en ds-2026-10-01, no ahí.
Escritura condicional (If-None-Match)conditional writeUna escritura (un PUT, la petición que guarda un archivo) que solo se cumple si se cumple una condición. Con el header If-None-Match: *, S3, el almacén de archivos de AWS, guarda el objeto solo si no existe nada con ese nombre; si existe, responde con el error 412 y no toca nada.Más +
Sin condición, en un object storage gana el último PUT y el anterior se pierde sin aviso. La escritura condicional cambia eso: If-None-Match: * quiere decir «solo si la llave está vacía». S3 la acepta desde agosto de 2024. Como el header lo pone quien escribe, para que sea obligatoria se exige en la política del bucket (bucket policy): se niega cualquier PUT bajo el prefijo que no lo traiga. Es lo que vuelve real la inmutabilidad (de un snapshot) de un prefijo; el versionado del bucket y Object Lock no la dan.
Ejemplo. Un job de Alba que por error intenta escribir otra vez datasets/ds-2026-09-01/rows.parquet recibe 412 Precondition Failed; el snapshot de septiembre sigue igual.
Object LockObject LockUna función de S3, el almacén de archivos de AWS, que bloquea cada versión de un objeto durante un plazo: nadie la puede borrar ni cambiar mientras dure. No impide escribir otra versión en la misma llave.Más +
Object Lock trabaja sobre el versionado del bucket: cada PUT crea una versión, y la versión bloqueada no se puede borrar hasta que venza su plazo (en el modo más estricto, ni quien administra la cuenta). Sirve para que un borrado por error o malicioso no destruya datos. Su hueco: protege versiones, no la llave. Un PUT nuevo a la misma llave crea otra versión que pasa a ser la que se lee, y quien pide el objeto sin decir qué versión recibe la nueva. Para impedir eso hace falta la escritura condicional; para detectarlo, la huella del manifest.
Ejemplo. Con Object Lock y sin escritura condicional, un PUT a rows.parquet de septiembre «funciona»: la versión vieja sigue guardada, pero el entrenamiento lee la nueva. El rows_sha256 del modelo ya no coincide, y así se descubre.
Escribir, auditar, publicarwrite-audit-publishUn patrón para publicar datos sin que nadie vea algo a medias o sin revisar: se escribe aparte, se corren los chequeos y solo si pasan se publica, de golpe.Más +
Si un job escribe directo donde los demás leen y se cae a la mitad, o escribe datos malos, quien lea en ese momento usa basura. Con este patrón, el job escribe en un lugar aislado (un prefijo temporal o una rama de lakeFS), corren los chequeos del contrato de datos y, si pasan, un último paso publica todo de una vez (subir los archivos al prefijo final y escribir la tarjeta al final, o hacer merge de la rama, que la junta con la principal). Si fallan, no se publica nada y el resto del sistema sigue con la versión anterior.
Ejemplo. Alba escribe el manifest en staging/ds-2026-09-01/, corre los chequeos del manifest ya armado (que ninguna foto esté en train y en validación, que no haya fotos del golden set, volumen entre 0.8 y 1.5 veces el snapshot anterior, labels débiles en 80 % o menos; el esquema y el rango de labels se revisaron antes de armar) y solo entonces sube los archivos a datasets/ con PUT condicional (no los copia dentro de S3) y escribe snapshot.json al final. Un snapshot sin tarjeta no existe.
Labels como eventosappend-only labelsGuardar cada etiqueta como una fila nueva que nunca se edita, con su autor, su fuente y su hora. Corregir es agregar otra más nueva; un snapshot (la foto fija del dataset) es la consulta «labels vigentes a tal fecha».Más +
Si la tabla de labels guarda una fila por foto y cada corrección la reescribe, se pierde qué label había antes, y un dataset viejo ya no se puede explicar. Con eventos de solo agregar (append-only), la historia completa sobrevive: para armar el snapshot de una fecha se toma, para cada foto, el evento más reciente anterior a ese corte. Es el point-in-time aplicado a las etiquetas: el snapshot con corte el 1 de octubre no puede ver un label que llegó el 4.
Ejemplo. Una foto tiene «Tenis» de quien vende el 25 de junio y «Botas» de moderación el 10 de agosto. El snapshot de julio (corte 1 de agosto) trae «Tenis»; el de agosto (corte 1 de septiembre), «Botas»; los dos eventos siguen en la tabla.
Split establestable splitUn reparto de los datos en el que cada ejemplo cae en train o en validación una vez y se queda ahí en todas las versiones. Los nuevos se reparten sin mover a los viejos.Más +
Si cada versión del dataset sortea el split otra vez, fotos que validaron al modelo viejo entrenan al nuevo, y ya no se pueden comparar. Se logra decidiendo el lado con un hash de algo fijo: un hash no cambia, así que el mismo grupo cae siempre en el mismo lado (asignación con hash). Si se repartiera al azar cada mes, con 95 % a train, la fracción de fotos que pasa por validación al menos una vez en un año sería 1−
Ejemplo. Alba: cubeta = SHA-256(seller_id) mod 100; train si es menor que 95. El vendedor s-309 cae en la cubeta 95: validación, hoy y siempre. Sortear cada mes movería ≈ 87,796 de las 92,417 fotos de validación de septiembre a train en octubre.
Ficha del datasetdatasheet / data cardEl documento que acompaña a un dataset: qué contiene, de dónde salió, cómo se etiquetó y dividió, y para qué no sirve. Hay una versión para máquinas (la tarjeta) y otra para personas.Más +
Un manifest dice qué filas hay, pero no por qué. La ficha lo cuenta. La parte para máquinas (en Alba, snapshot.json) guarda el id, el padre, la fecha, la huella del manifest, los conteos, la mezcla de fuentes, la regla del split, el commit del código que lo armó y el estado de la validación. La parte para personas, que viene de la propuesta de datasheets for datasets, explica los límites: qué sesgos tiene, qué no se debe medir con él.
Ejemplo. La tarjeta de ds-2026-09-01 dice: padre ds-2026-08-01, 72 % de labels de quien vende filtrados, 7 % de moderación, 21 % a mano; split por seller_id; código ml-catalogo en el commit 4be1d0a. La ficha para personas avisa que el 72 % no sirve para medir el modelo: lo influyó su propia sugerencia.
DVCDVC (Data Version Control)Una herramienta de código abierto que versiona datos junto con Git: guarda en Git un archivo chiquito con la huella de cada dataset, y los datos de verdad en un almacén aparte, como S3 (el almacén de archivos de AWS).Más +
DVC calcula la huella de cada archivo o carpeta de datos y la escribe en un archivo .dvc de texto, que sí entra a Git. Los datos suben a un remote (un bucket, por ejemplo). Hacer checkout de un commit viejo y luego dvc checkout trae los datos de ese commit. Es la idea de Git LFS, pensada para datasets, y además describe pasos de pipeline. Va bien con equipos chicos y miles o cientos de miles de archivos; con millones de archivos chicos, calcular y comparar huellas se vuelve lento.
Ejemplo. Un proyecto de escuela con 30,000 fotos: dvc add fotos/ crea fotos.dvc con la huella, ese archivo va al commit, y dvc push sube las fotos al bucket. Alba no lo usa: prefiere prefijos inmutables con manifest.
lakeFSlakeFSUn sistema que pone ramas, commits y merges, como los de Git (las versiones del código), encima de un bucket (una carpeta de archivos en la nube), sin copiar los datos.Más +
lakeFS guarda, para cada commit, la lista de qué objetos forman el bucket en ese momento. Crear una rama no copia nada: la rama nueva apunta al mismo commit, así que tarda lo mismo con 1 KB que con 400 GB. Su uso estrella es escribir, auditar, publicar: un job escribe en su rama, unos chequeos corren antes del merge y el merge publica todo de golpe. Hay que operarlo: es un servidor más, con su base de datos. Desde la versión 1.87.0 (septiembre de 2026) su licencia es la BSL 1.1 (Business Source License), ya no la Apache 2.0, de código abierto: se usa gratis dentro de la empresa sin modificarlo, pero no se puede ofrecer como servicio. Le conviene a equipos grandes con muchos jobs que escriben al mismo lake.
Ejemplo. Un equipo de 40 personas: cada job de ingesta escribe en su rama, y solo lo que pasa los chequeos llega a main. Alba, con 5 personas, no lo necesita todavía.
Formato de tabla (Delta, Iceberg)table formatUna capa sobre archivos de datos (como Parquet, un formato para tablas) que los convierte en una tabla con transacciones y versiones: un registro aparte dice qué archivos forman la tabla en cada versión. Los más usados son Delta Lake y Apache Iceberg.Más +
Es la pieza que hace posible el lakehouse. Cada escritura sube archivos nuevos y, al final, agrega al registro una entrada con la lista de archivos de la versión nueva: quien lee nunca ve una tabla a medias. Como las versiones viejas siguen listadas mientras sus archivos existan, se puede leer el pasado: el time travel. Le conviene a datos tabulares que cambian fila por fila (transacciones, precios, features).
Ejemplo. Un sistema de pronóstico de demanda guarda sus ventas en una tabla Iceberg; cada entrenamiento nocturno lee la versión del momento en que arranca y registra su número con el modelo.
Time travel de una tablatime travelLeer una tabla como estaba en una versión o una fecha pasada. Lo dan los formatos de tabla, pero solo mientras la limpieza no borre esa versión: no es un archivo para siempre.Más +
Un formato de tabla guarda qué archivos formaban cada versión, y con eso se puede pedir VERSION AS OF o TIMESTAMP AS OF. Para no pagar archivos viejos para siempre, la limpieza borra las versiones que pasan de cierta edad: en Delta, por omisión, el registro guarda 30 días, pero VACUUM, si corre, borra los archivos de las versiones de más de 7; en Iceberg, la limpieza borra por omisión los snapshots de más de 5 días. Una versión se puede releer si su edad E es menor o igual que su retención L. Para reproducir un modelo, la versión que usó se guarda aparte: en Iceberg, con un tag (un nombre fijo para esa versión) de retención larga; en Delta, que no tiene tags, con una retención más larga en la tabla o una copia.
Ejemplo. Un modelo se entrenó con una tabla Iceberg al 1 de septiembre de 2026. El 15 de diciembre, E = 105 días: con la limpieza de 5 días, lo más probable es que ya se haya borrado. Con un tag RETAIN 365 DAYS en esa versión, se puede hasta el 1 de septiembre de 2027.
LinajelineageLa cadena de qué salió de qué: este modelo salió de este snapshot, armado por este código, con fotos que tienen estas huellas. Se guarda como punteros, no como copias.Más +
Con linaje, las preguntas de producción son mecánicas: con qué datos se entrenó un modelo, si cambió el código o los datos entre dos versiones, en qué modelos está una foto que hay que borrar. En Alba, cada modelo registrado guarda tres punteros: el snapshot (id y huella), el commit del código de entrenamiento y el digest (la huella) de la imagen de contenedor donde corrió el entrenamiento; además, labels.json con su huella y la versión del preprocesamiento. El snapshot, a su vez, apunta al commit que lo armó y a cada foto por su huella. Sin linaje, cada pregunta es una semana de arqueología.
Ejemplo. resnet50-2026-10-01 → ds-2026-09-01 (y su rows_sha256) → manifest → la foto de Ana por su SHA-256; y del otro lado, el commit c3f2fc2 y el digest de la imagen. El snapshot apunta a 4be1d0a, el código que lo armó.
ReproducibilidadreproducibilityPoder volver a entrenar un modelo y obtener el mismo resultado. Exige fijar cinco ingredientes: código, datos, configuración, entorno y aleatoriedad.Más +
Cada ingrediente se fija con un puntero: el código con un commit (con el árbol limpio), los datos con un snapshot y su huella, la configuración en el mismo commit, el entorno con el digest (la huella) de la imagen de contenedor y la aleatoriedad con la semilla. Aun así, en una GPU dos corridas casi nunca dan los mismos bits (determinismo), por eso hay tres niveles: bit a bit, dentro de tolerancia (métricas que difieren tan poco como dos semillas) y estadístico. Lo normal en producción es el segundo.
Ejemplo. Alba entrenó la misma receta con 5 semillas: 85.12 a 85.34 %, promedio 85.23 %, desviación estándar σ ≈ 0.088 puntos. Su tolerancia es 3σ ≈ 0.26: una repetición que da 85.41 % se reprodujo; una que da 85.71 %, no.
Orquestador de pipelinesworkflow orchestratorEl programa que corre los pasos de un pipeline: decide cuándo y en qué orden, reintenta el que falla, guarda qué entró y salió de cada uno y avisa si algo se rompe. No procesa datos: los procesan los pasos.Más +
Un pipeline de machine learning (validar, armar el snapshot, entrenar, evaluar, registrar) no se corre a mano: lo corre un orquestador como Argo Workflows, Airflow, Dagster o Kubeflow Pipelines. El pipeline se describe como un DAG; cada paso suele ser un contenedor con entradas explícitas. El orquestador da reintentos por paso, caché, historial, parámetros y disparadores (una hora, un evento). No es la orquestación de Kubernetes, que mantiene vivos los contenedores de un servicio: este corre tareas que empiezan y terminan.
Ejemplo. En Alba, un CronWorkflow (una tarea con horario fijo) de Argo Workflows dispara el pipeline mensual el día 1 a las 03:00 UTC, en el mismo cluster de Kubernetes; si un paso falla, avisa a la persona de guardia.
DAGDAG (directed acyclic graph)Un grafo dirigido acíclico: pasos unidos por flechas que dicen «este va después de aquel», sin ciclos. Es como se describe un pipeline.Más +
Dirigido, porque cada flecha tiene sentido (de una dependencia a quien la necesita); acíclico, porque un paso no puede esperar, aunque sea de rebote, a uno que lo espera a él: nadie empezaría. Con el DAG, el orquestador sabe qué pasos pueden correr a la vez (los que no dependen entre sí) y cuál es el camino más largo, que fija cuánto tarda todo.
Ejemplo. El pipeline mensual de Alba: validar datos → armar snapshot → fine-tune → evaluar → gate (el examen que decide si el modelo nuevo entra) → construir el engine (el modelo compilado para la GPU) en una T4 → paridad (comparar el engine con el original) → registrar. 8 pasos en fila, 4 con GPU (dos en una A10G y dos en una T4).
Caché de pasos de un pipelinestep cacheGuardar la salida de cada paso y reusarla si el paso vuelve a correr con las mismas entradas. Si una entrada llega como una ruta (el nombre de una carpeta), la llave usa el nombre y no lo que hay dentro: por eso una carpeta «latest», que cambia de contenido cada mes, la engaña.Más +
La llave es H(código + parámetros + entradas). Si coincide con una guardada, el paso no corre y se usa la salida vieja: ahorra horas de GPU. Pero cuando una entrada llega como una ruta de texto, el orquestador calcula el hash de la ruta, no de lo que hay en ella. Si una se llama datasets/latest y su contenido cambió, la llave no cambia y se reusa un resultado viejo, con el pipeline en verde. La regla: toda entrada que cambia el resultado va como parámetro o artefacto con nombre fijo.
Ejemplo. Con datasets/latest, la corrida del 1 de noviembre de Alba «entrena» en segundos y registra el modelo de octubre otra vez. Con ds-2026-10-01 como parámetro, la llave cambia y el fine-tune corre.
Chequeo
EsencialCheck
Intenta responder en tu cabeza antes de abrir cada respuesta.
1¿Por qué el snapshot de Alba pesa ≈ 0.1 % de las fotos que usa?Ver respuesta
Porque no las copia: el manifest cita cada foto por su llave y su huella, ≈ 200 B por fila contra ≈ 200 KB por foto. La fracción es r÷
f y no depende de cuántas fotos haya.2¿Qué hueco deja Object Lock que cierra la escritura condicional?Ver respuesta
Object Lock protege cada versión, pero un PUT a la misma llave crea otra versión que pasa a ser la leída. Con
If-None-Match: *, exigido por la política del bucket, ese PUT falla con 412.3¿Por qué la tarjeta se escribe al final?Ver respuesta
Porque un snapshot sin tarjeta no existe: quien entrena la lee primero. Si el job se cae a la mitad, queda un manifest huérfano que nadie usa, no un snapshot a medias.
4¿Qué es un split estable y cómo lo logra Alba?Ver respuesta
Un reparto donde cada foto se queda siempre en train o siempre en validación, de versión en versión. Alba lo logra con un hash del
seller_idmod 100: el mismo vendedor cae siempre en la misma cubeta.5¿Cuáles son los cinco ingredientes de un entrenamiento y qué puntero fija cada uno?Ver respuesta
Código (el commit), datos (el snapshot y su huella), configuración (en el mismo commit), entorno (el digest de la imagen) y aleatoriedad (la semilla).
6¿Por qué un paso de pipeline no debe recibir
datasets/latest?Ver respuestaPorque la caché hashea el nombre de la entrada, no su contenido: el mes siguiente la llave es la misma y se reusa la salida vieja. Toda entrada que cambia el resultado va como parámetro con nombre fijo.
7Si Ana pide borrar sus fotos, ¿por qué no se reescribe el snapshot de septiembre?Ver respuesta
Porque se rompería la huella que guarda el modelo de octubre y no se sabría si el cambio fue un borrado o un error. Se anota en el registro de borrados y el siguiente snapshot ya no las trae.