SenseiTeoría desde cero0/59

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.

⏱ 60 min lo esencial · 79 min todo18 conceptos nuevos2 calculadoras10 ejerciciosDatos
Secciones14
  1. 01Qué entra y qué sale de la estación
  2. 02El manifest y la tarjeta
  3. 03Que nadie lo pise
  4. 04Labels como eventos y split estable
  5. 05Cuatro formas de versionar extra
  6. 06Linaje y reproducibilidad
  7. 07El pipeline mensual como DAG
  8. 08Borrar sin romper la historia extra
  9. 09Errores comunes
  10. 10En la vida real extra
  11. 11Ejercicios
  12. 12Lo que sigue
  13. 13Palabras que vas a oír
  14. 14Chequeo
La pregunta

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.

01

Qué entra y qué sale de la estación

Esencial

What 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-v4 en 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:

  1. Qué guarda el snapshot y cómo se describe: el manifest y la tarjeta.
  2. Cómo se impide que alguien lo pise: la escritura condicional y la publicación al final.
  3. Cómo se reparten las fotos entre train y validación sin que se muevan de un mes a otro: el split estable.
  4. 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).
  5. Qué apunta a qué: del modelo al snapshot, al commit y a cada foto. Eso es el linaje.
El día 1 de cada mes: de los labels al snapshot publicado · Arriba, lo que se arma aparte; abajo, lo que ya leen los entrenamientos. Toca cada caja para ver por qué está ahí, y usa «Recorrer» para seguir el snapshot de septiembre y una auditoría que falla.
  • 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_id entre 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 del seller_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 en validation.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 su rows_sha256 y la huella de cada foto al leer.
  • Publicar · datasets/ds-2026-09-01/
    Se suben rows.parquet y validation.json al prefijo definitivo con PUT y escritura condicional: la política del bucket rechaza cualquier PUT sin If-None-Match: *, y Alba no copia dentro de S3: la guía de AWS dice que la copia falla, aunque desde octubre de 2025 CopyObject acepta 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.

02

El manifest y la tarjeta

Esencial

The 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:

ColumnaQué guardaEjemplo
image_keyla llave de la foto en el almacenamiento del productofotos/2026/08/02/a01.jpg
image_sha256la huella SHA-256 de los bytes de la foto64 caracteres hexadecimales (0–9 y a–f)
seller_idquién la publicó (decide el split)s-104 (un id de juguete)
label_idla categoría, de 0 a 49917
label_sourcede dónde salió el labelhumano, moderador o vendedor_filtrado
guia_versionla guía con que se etiquetóguia-v4
splita qué parte vatrain o val
width, heightel tamaño de la foto, en píxeles1200, 900
created_atcuándo se publicó, en UTC2026-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.

Python
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])
Salida
rows_sha256: 9c3ec1ab181a · 598 bytes · 60 B por fila
una etiqueta distinta: 4fab4aa4f20b
mismas filas, otro orden: 9c3ec1ab181a

Una 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.

Cómo está hecho un snapshot de Alba. Arriba, el manifest: una tabla con una fila por foto, con la llave de la foto, su huella SHA-256, su etiqueta y su split; en total 1,932,628 filas y unos 100 MB en Parquet. En medio, las fotos: unos 400 GB que se quedan en el almacenamiento del producto y que el manifest cita por llave y huella, sin copiarlas. Abajo, la huella de toda la lista, rows_sha256, que se guarda en la tarjeta del snapshot y en el modelo. Si cambia una sola etiqueta, la huella cambia. EL MANIFEST: UNA FILA POR FOTO LLAVE HUELLA LABEL SPLIT …/08/02/a01.jpg9b1e…17train …/08/03/b11.jpge2a0…233val …/08/04/c31.jpg71f5…233train …/08/05/d07.jpg0d93…90train … 1,932,628 filas · ≈ 100 MB en Parquet CITA LAS FOTOS, NO LAS COPIA ≈ 400 GB, en el bucket del producto El manifest pesa ≈ 0.1 % de lo que cita. LA HUELLA DE TODA LA LISTA rows_sha256 = 5d1f…e7a2 snapshot.json la guarda el modelo la guarda Cambia la etiqueta resaltada y la huella es otra.
Un snapshot no copia fotos: es una lista. Cada fila cita una foto por su llave y su huella; la huella de toda la lista va en la tarjeta, y el modelo guarda esa huella.

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:

Lo que pesa y cuesta un snapshot
M=N×r
F=N×f
costocitar=k×Mz×c
costocopiar=k×F×c
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÷F=r÷f dice cuánto cuesta un snapshot comparado con copiar las fotos: no depende de cuántas fotos haya.

El snapshot de septiembreLa cuenta
Filas, Nla ficha de Alba
1,840,211 + 92,417
1,932,628
Bytes por fila, restimado del equipo de Alba
10 columnas, la huella de 64 caracteres
≈ 200 B
Manifest, M=N×r≈ 400 MB redondeado
1,932,628 × 200 B
≈ 387 MB
Bytes por foto, fla ficha de Alba
la foto que sube la app, ya reducida (el original del celular pesa ≈ 3 MB)
≈ 200 KB
Fotos citadas, F=N×f≈ 400 GB redondeado
1,932,628 × 200 KB
≈ 387 GB
Fracción, M÷F=r÷f
200 B ÷ 200,000 B
0.001 = 0.1 %
Manifest guardado, M÷zz ≈ 4, estimado del equipo de Alba con compresión zstd; la huella no baja de sus 32 B; ≈ 100 MB redondeado
387 MB ÷ 4
≈ 97 MB
Un año de manifests, k×M÷zk = 12
12 × 97 MB
≈ 1.16 GB
Costo de citar, k×M÷z×cc = US$0.023 por GB al mes, S3 Standard, us-east-1
1.16 GB × 0.023
≈ US$0.03 al mes
Costo de copiar, k×F×cuna copia de las fotos por snapshot
12 × 387 GB × 0.023
≈ US$107 al mes
Resultado
Un snapshot cuesta ≈ 0.1 % de copiar las fotos. Un año de snapshots cuesta tres centavos al mes; copiar las fotos, ≈ US$107, y crece cada mes.

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»).

Cuánto pesa versionar: citar contra copiarCalculadora

Aplica las cuatro ecuaciones de la lección (M=N×r, F=N×f y los dos costos) y compara guardar k snapshots que citan las fotos (un manifest en Parquet, comprimido z veces) contra copiar las fotos en cada uno. Arranca con el snapshot de septiembre de Alba y un año de snapshots, a c = US$0.023 por GB al mes (S3 Standard).

Manifest sin comprimir, MM=N×r387 MB
Manifest en Parquet, M÷zlo que de verdad se guarda por snapshot96.6 MB
Fotos citadas, FF=N×f: se quedan donde están387 GB
Manifest contra fotos, M÷Fr÷f: no depende de N0.10 %
Costo de citar: guardar los k manifests, en US$ al mescostocitar=k×M÷z×c0.03
Costo de copiar: una copia de las fotos por snapshot, en US$ al mescostocopiar=k×F×c107

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:

JSON
{
  "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.

03

Que nadie lo pise

Esencial

Nobody 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:

JSON
{
  "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.

El mismo PUT a una llave que ya existe, rows.parquet, en tres buckets. Primero, sin protección: el objeto viejo se reemplaza en silencio y se pierde. Segundo, con versiones u Object Lock: la versión vieja sobrevive, pero la nueva pasa a ser la que se lee, y el entrenamiento recibe la nueva; solo la huella guardada por el modelo lo delata. Tercero, con escritura condicional If-None-Match exigida por la política del bucket: S3 responde 412 y no cambia nada. UN PUT A rows.parquet, QUE YA EXISTE 1 · Sin protección v. septiembre otra La vieja se pierde. Nadie se entera. 2 · Con versiones u Object Lock v. septiembre otra · la que se lee La vieja sobrevive, pero el entrenamiento lee la nueva. Solo la huella del modelo lo delata. 3 · Escritura condicional v. septiembre 412 «ya existe»: no cambia nada La política del bucket niega todo PUT bajo datasets/ que no traiga If-None-Match: *
Tres buckets reciben el mismo 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. 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. 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_id entre 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 a validation.json.

  3. 3

    Publicar o detenerse

    Si todo pasa, se suben con PUT el manifest y el reporte a datasets/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.

04

Labels como eventos y split estable

Esencial

Labels 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.

Python
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"))
Salida
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 val

El 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.

El split por hash
cubeta=H(seller_id) mod 100
train si cubeta<u, validación si no
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.

Lo que se mueve si se sortea otra vez
Y=V×u100
W=1−(u100)T
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
Sortear el split cada mesLa cuenta
Validación de septiembre, Vla ficha de Alba
ds-2026-09-01
92,417 fotos
Umbral, u
hash mod 100 < 95 → train
95
Se mueven a train en el snapshot de octubre, Y=V×u/100
92,417 × 0.95
≈ 87,796 fotos
Meses sorteando, T
un año
12
Nunca en validación en 12 sorteos, (u/100)T
0.95¹²
≈ 0.540
Alguna vez en validación, W=1−(u/100)T
1 − 0.540
≈ 0.460 = 46 %
Resultado
Con un sorteo nuevo cada mes, el modelo de noviembre entrena con ≈ 87,796 de las fotos con que se validó el de octubre, y en un año casi la mitad de las fotos pasó por validación. Comparar dos modelos así es comparar uno que ya vio el examen contra otro que no.
Sortear el split cada mes contra un split por hashCalculadora

Aplica las ecuaciones de la lección, Y=V×u/100 y W=1−(u/100)T: cuántas fotos de validación pasarían a train si el split se sorteara otra vez cada mes, y qué fracción de las fotos pasaría por validación alguna vez. Arranca con la validación de septiembre de Alba y un año.

Fotos de validación que pasan a train en un mes, YY=V×u/10087,796
Fracción que pasó por validación alguna vez, WW=1−(u/100)T46.0 %
Fracción que nunca estuvo en validación(u/100)T54.0 %
Fotos que se mueven con el split por hashel mismo vendedor cae siempre en la misma cubeta0

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.

05

Cuatro formas de versionar

Extra

Four 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 + manifestDVClakeFSDelta / Iceberg
Qué versionalistas de archivosarchivos y carpetastodo un buckettablas
Dónde vive la versiónun prefijo y su tarjetaun archivo chico en Gitun commit de lakeFSel registro de la tabla
Ramas para probarnolas de Gitsí, sin copiarIceberg sí (ramas y tags); Delta no
Hay que operarnadacasi nadaun servidor y su baseun motor de consultas que lo lea (Spark, Trino…)
Lo malosin la política, convenciónlento con millones de archivosotro sistema que mantenerla retención borra el pasado
Le conviene afotos que no cambianequipos chicosequipos grandes con muchos jobsdatos 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:

¿Se puede releer una versión?
E≤L
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>L: no se puede.

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:

  1. 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.
  2. 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.logRetentionDuration y delta.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.
06

Linaje y reproducibilidad

Esencial

Lineage 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: c3f2fc2 en 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.

El linaje de un modelo: de la respuesta en producción a cada foto · El linaje de un modelo de Alba, de la respuesta que da en producción hasta cada foto. Recorre las dos preguntas: con qué datos se entrenó y en qué modelos está una foto.
  • Respuesta · model_version
    Cada respuesta del servicio y cada línea del log llevan model_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) y labels.json. No copia nada: apunta.
  • labels.json · id → categoría, con huella
    Traduce cada label_id a 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 repositorio ml-catalogo. Lo dice la tarjeta en code.
  • 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-01 y 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_sha256 de 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:

IngredienteQué esCómo lo fija Alba
Códigoel programa de entrenamientoel commit, con el árbol limpio
Datosqué fotos y con qué labelel snapshot y su rows_sha256
Configuraciónla 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
EntornoPython, PyTorch, CUDA y los drivers de la GPUel digest de la imagen de entrenamiento
Aleatoriedadel orden de las fotos, las variaciones al azarla 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»:

  1. Bit a bit: los mismos pesos (los números que el modelo aprendió), byte por byte. Caro y frágil en GPU.
  2. Dentro de tolerancia: las métricas se parecen tanto como se parecen dos corridas con distinta semilla. Es el nivel de Alba.
  3. 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:

Desviación estándar de las semillas
x̄=1ss∑i=1xi
σ=√1s−1s∑i=1(xi−x̄)2
τ=3×σ
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
Cuánto varían cinco semillasLa cuenta
Corridas, silustrativo, del equipo de Alba
una por semilla
5
Suma de las exactitudes, ∑xien %
85.21 + 85.34 + 85.12 + 85.29 + 85.18
426.14
Promedio, x̄
426.14 ÷ 5
85.228 ≈ 85.23 %
Diferencias, xi−x̄en puntos; siempre suman cero
−0.018, +0.112, −0.108, +0.062, −0.048
suman 0
Suma de cuadrados∑(xi−x̄)2
0.000324 + 0.012544 + 0.011664 + 0.003844 + 0.002304
0.03068
Varianza, σ2la suma ÷ (s−1)
0.03068 ÷ 4
0.00767
Desviación estándar, σ
√0.00767 = 0.0876
≈ 0.088 puntos
Tolerancia, τ=3×σ
3 × 0.088
≈ 0.26 puntos
Resultado
τ ≈ 0.26 puntos: la distancia máxima a 85.23 % para decir que el modelo de octubre «se reprodujo».

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»: ε=1.96×√a(1−a)/G, donde a es la exactitud como fracción (0.85), G son las fotos del golden set (50,000), ε es el margen, también como fracción, y 1.96 es el número que deja dentro el 95 % de los casos. Da ε ≈ 0.0031: ± 0.3 puntos. Las dos reglas dicen lo mismo con distinto origen: una diferencia de 0.2 puntos entre dos corridas no dice nada de la receta.

Python
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ó")
Salida
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ó
07

El pipeline mensual como DAG

Esencial

The 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):

YAML
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.

La llave de la caché
llave=H(código+parámetros+entradas)
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.

Python
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"))
Salida
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 -> entrena

Con 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.

La caché de un pipeline y la trampa de latest. Arriba, la entrada se llama datasets/latest: en octubre y en noviembre la llave de la caché sale igual, porque se calcula con el nombre y no con el contenido; en noviembre el paso no corre y se reusa el modelo de octubre. Abajo, la entrada es el id del snapshot: ds-2026-09-01 en octubre y ds-2026-10-01 en noviembre dan llaves distintas, y el paso corre cada mes. LLAVE = H(CÓDIGO + PARÁMETROS + ENTRADAS) Con «datasets/latest» 1 OCT llave 10d32e… entrena 1 NOV llave 10d32e… reusa octubre La carpeta cambió de contenido, pero no de nombre: la llave es la misma y el paso no corre. Con el id del snapshot 1 OCT ds-2026-09-01 llave 4dec1a… 1 NOV ds-2026-10-01 llave 7262ec… Otra llave cada mes: el paso corre y entrena con los datos nuevos. Lo que cambia el resultado va como parámetro.
La misma receta, dos meses. Con 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, donde dt es 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:

Duración de un backfill
D=⌈Pj⌉×d
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
Recalcular 180 días de una featureLa cuenta
Particiones, Psupuesto: una feature nueva de un sistema de pronóstico de demanda
180 días
180
Minutos por partición, d
supuesto
20 min
En serie, j = 1
⌈180 ÷ 1⌉ × 20
3,600 min = 60 h
Doce a la vez, j = 12
⌈180 ÷ 12⌉ × 20 = 15 × 20
300 min = 5 h
Resultado
Con 12 a la vez, de dos días y medio a 5 horas. Pero 12 jobs leyendo al mismo tiempo pueden saturar la base o el bucket de donde leen: por eso el orquestador lleva un tope de paralelismo, y no se sube sin medir.
08

Borrar sin romper la historia

Extra

Deleting 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. 1

    Encontrar con las huellas

    Con las huellas SHA-256 de las fotos de Ana se consulta la columna image_sha256 de todos los manifests, del golden set y de las fotos que salieron a etiquetar (labeled/): aparecen en ds-2026-09-01 y en los snapshots anteriores que las traigan. El de octubre todavía no existe: se arma el 1 de noviembre.

  2. 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. 3

    Los modelos

    resnet50-2026-10-01, en producción, tiene a Ana y sirve hasta que lo reemplaza resnet50-2026-11-01, entrenado con ds-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.

09

Errores comunes

Esencial

Common 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.

10

En la vida real

Extra

In 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.

11

Ejercicios

Esencial

Exercises

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.

  1. 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×r: 1,932,628 × 260 B ≈ 502 MB, ≈ 0.5 GB sin comprimir.
    • Fracción r÷f = 260 ÷ 200,000 = 0.0013 = 0.13 %. Sigue siendo casi nada: no depende de cuántas fotos haya.
  2. 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.
  3. 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 trae ds-2026-08-01, el snapshot de agosto, con corte el 1 de septiembre? ¿Y ds-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 con guia-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.
  4. 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⌉×d: en serie, 90 × 15 = 1,350 min = 22.5 h. Con j = 10: ⌈90 ÷ 10⌉ × 15 = 9 × 15 = 135 min ≈ 2.3 h.
    • 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 con now().
  5. 5Medio

    Para encontrar las fotos de Ana hay que leer la columna image_sha256 de 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.
  6. 6Reto

    La ingeniera de guardia repite el entrenamiento de resnet50-2026-10-01 y 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.
  7. 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_sha256 que el de octubre.
    • Arreglo: el id del snapshot entra como parámetro (ds-2026-10-01 en 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.
  8. 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.
12

Lo que sigue

Esencial

What 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.
13

Palabras que vas a oír

Esencial

Words 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.

Ver en el glosario →

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.

Ver en el glosario →

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í.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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−0.9512 ≈ 46 %.

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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ó.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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).

Ver en el glosario →

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.

Ver en el glosario →

14

Chequeo

Esencial

Check

Intenta responder en tu cabeza antes de abrir cada respuesta.

  1. 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. 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. 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. 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_id mod 100: el mismo vendedor cae siempre en la misma cubeta.

  5. 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. 6¿Por qué un paso de pipeline no debe recibir datasets/latest?Ver respuesta

    Porque 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.

  7. 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.

Repasar los 18 conceptos de esta lección con tarjetas Sigue · 49Entrenamiento y experimentosEstaciones · Modelo Practícalo con códigoEstación 2 del Dojo: Versionado y linajeEl Dojo es la parte de TrueML donde construyes, rehaces y rompes cada pieza del sistema de Alba con Claude Code. ← 47 · Datos y etiquetas