SenseiTeoría desde cero0/59

14 · Estaciones · MonitoreoLección 2 de 2

Monitoreo, drift y reentrenamiento

Monitoring, drift and retraining

El último paso del sistema de Alba: vigilar el servicio y el modelo en cinco capas, alertar solo cuando alguien puede y debe actuar, notar cuándo el mundo se movió y convertir esa señal en una decisión, con diagnóstico, antes de reentrenar.

⏱ 58 min lo esencial · 78 min todo21 conceptos nuevos2 calculadoras10 ejerciciosMonitoreo
Secciones16
  1. 01Lo que entra, lo que sale y lo que se decide
  2. 02Las fallas silenciosas y las cinco capas
  3. 03Las señales de servicio de Alba
  4. 04Una alerta bien hecha
  5. 05Burn rate: alertar con el presupuesto
  6. 06El modelo sin labels: baja confianza, score y PSI
  7. 07Los labels que llegan tarde
  8. 08Del aviso a la decisión: diagnosticar antes de reentrenar
  9. 09Vigilar al que vigila: el job diario y su frescura extra
  10. 10La guardia: dashboards, runbooks, fatiga y postmortems extra
  11. 11Errores comunes
  12. 12En la vida real extra
  13. 13Ejercicios
  14. 14Lo que sigue
  15. 15Palabras que vas a oír
  16. 16Chequeo
La pregunta

Todo contesta 200 OK, en 20 milisegundos, y el modelo empeora sin que nadie lo note. ¿Cómo se entera Alba, quién se despierta y quién no, y cuándo se manda a entrenar el modelo siguiente?

Imagina un martes cualquiera. El servicio contesta todo con 200 OK, el código de «todo bien». El p99 (el tiempo que deja abajo al 99 % de las requests) de cada pod del gateway (cada copia del programa que recibe las fotos) no pasa de ≈ 69 ms ni con el tráfico más alto para el que se diseñó. Los errores están en su nivel de siempre. Pero desde el viernes una versión nueva de la app del celular manda las fotos más comprimidas, y el modelo acierta un poco menos en esas fotos. Nadie lo ve en el dashboard (la página de gráficas) del servicio, porque para el servicio no pasó nada. Esta lección trata de cómo se nota eso, quién se entera, cuándo, y qué se hace con la señal.

01

Lo que entra, lo que sale y lo que se decide

Esencial

In, out and what gets decided

Alba es la empresa del curso: un marketplace en línea que recibe ≈ 2.5 millones de publicaciones nuevas al día y sugiere la categoría de cada foto entre 500 (el árbol tiene 501 desde que el 1 de octubre se agregó «bolsas», que el modelo en producción todavía no conoce). Con las fotos que piden otros equipos de Alba (moderación y búsqueda) son ≈ 10 millones de requests al día, una foto por request: ≈ 116 por segundo en promedio, ≈ 350 en el pico del día y 500 en su pico de diseño, el tráfico para el que se compraron las máquinas. La sugerencia la hace una ResNet-50 compilada como engine de TensorRT y servida por Triton, el servidor de modelos de NVIDIA, en Kubernetes, en AWS (us-east-1). Delante de Triton está el gateway, el programa en Python que recibe la foto, la prepara y le pide la respuesta a Triton; corre en varios pods, copias iguales del mismo programa. En noviembre de 2026 atiende la release 14 (en Alba, una release es un par: un gateway y un Triton de la misma versión): el modelo resnet50-2026-10-01, con el alias champion (el champion es el modelo que atiende a la gente), en triton-v14, dos pods con una GPU T4 cada uno. El modelo se reentrena cada mes. Lo opera un equipo de 5 personas.

Alba promete dos cosas, sus SLO (service level objectives, las metas medibles del servicio): p99 ≤ 200 ms del lado del servidor (lo que tarda dentro de Alba, sin la red del usuario), y 99.9 % de las requests sin error del servidor en cada ventana de 30 días. Ese 0.1 % que sobra es su presupuesto de error: el 0.1 % de los ≈ 300 millones de requests de 30 días (10 millones × 30), ≈ 300,000 requests al mes; o, contado en tiempo, el 0.1 % de los 43,200 minutos del mes, 43.2 minutos.

Lo que entra

Lo que dejó «La request en vivo» y lo que llega después:

  • El log de cada request: una línea de ≈ 300 bytes por foto, con su request_id, el model_version, el source (de dónde viene la foto: mobile, la app del celular; web; internal, otro sistema de Alba; la métrica suma other), el top-5 (las 5 categorías más probables) con sus scores (la probabilidad que el modelo le da a cada una), los milisegundos de cada tramo, los bytes de la foto y el código de respuesta. Son ≈ 3 GB al día (300 bytes × 10 millones) que llegan a S3 por el camino del log y quedan en Parquet (tablas guardadas por columnas), partidos por día (dt) y por model_version: ≈ 0.5 GB al día, guardados 90 días.
  • Las métricas: los números con nombre que lleva cada pod, como classifier_requests_total, y que Prometheus lee cada 15 segundos.
  • Las trazas del ≈ 1 % de las requests (el recorrido de una request por cada programa, con lo que tardó en cada uno), y lo que mide el ALB (el balanceador de la entrada) en CloudWatch, el servicio de métricas de AWS.
  • Los eventos del backend de publicaciones, el programa que llama al clasificador: suggestion_shown (la pantalla pintó las 5 sugerencias) y category_selected (qué categoría quedó y por qué vía).
  • Las correcciones de moderación, cuando una persona de Alba cambia la categoría de una publicación ya hecha.
  • El holdout: el ≈ 1 % de las cuentas de vendedor que nunca ve sugerencias y elige la categoría a mano.

Lo que sale

  • Alertas con dueño y runbook: cada una dice quién la recibe y qué hacer.
  • Tickets cuando una señal del modelo se mueve: trabajo de la semana, no de las 3 de la mañana.
  • Un disparador de reentrenamiento: una corrida adelantada del pipeline mensual, que solo lanza una persona después de un diagnóstico.
  • Muestras para etiquetar: la cola del mes, ≈ 5,000 fotos que etiquetan personas pagadas, y, si un ticket lo pide, una tanda extra de un slice (un pedazo del tráfico que se mide por separado, como las fotos de un solo source). Con eso el ciclo vuelve a la estación 1.

Lo que se decide

  1. 1

    Qué se vigila y con qué retraso

    Unas señales llegan en segundos y otras en semanas.

  2. 2

    Qué despierta a alguien

    Un page despierta a la guardia, la persona de turno; un warning espera al horario; un ticket es trabajo de la semana.

  3. 3

    Cómo se alerta con el presupuesto

    Con qué tan rápido se gasta el presupuesto del mes, no con «más de 1 % de errores».

  4. 4

    Contra qué se compara el modelo

    Qué referencia, qué ventana y cuánto tiempo sostenido.

  5. 5

    Qué se descarta antes de reentrenar, y quién decide

    Un error propio no se arregla reentrenando, y nada se despliega solo.

02

Las fallas silenciosas y las cinco capas

Esencial

Silent failures and the five layers

Un servidor web roto se nota: deja de contestar, o contesta 500. Un modelo roto sigue contestando con la misma latencia y la misma confianza aparente. Eso es una falla silenciosa (silent failure): todo responde 200 OK mientras las predicciones empeoran.

Y casi nunca cambió el modelo. El engine de la release 14 es el mismo archivo que pasó el gate (el examen automático que decide si un modelo entra) en octubre; sus pesos no se mueven. Lo que cambió es el mundo que lo alimenta: las fotos, la gente, lo que se vende. Eso es el drift. A veces cambia lo que entra (una cámara nueva, la luz de noviembre); a veces cambia la relación entre lo que entra y la respuesta correcta, el concept drift (una categoría nueva que parte a otra en dos). Las dos cosas las ves a fondo en «Comparar distribuciones: cómo se mide el drift».

Cinco capas, de la más rápida a la más lenta

Para notar lo que no truena, Alba vigila cinco capas, cada una con sus señales y su retraso:

CapaQué mira en AlbaCuánto tarda en avisar
Infraestructuranodos, GPU, pods listossegundos
Serviciop99, errores 5xx, fila de Tritonsegundos a minutos
Datosbytes de las fotos por source, tasas de 400, 413 y 415minutos
Modeloscore top-1, tasa de baja confianza, PSI de las categoríasminutos a 1 día
Negocioaceptación, recategorización de moderación, holdouthoras a semanas

Los 400, 413 y 415 son los códigos con que el gateway rechaza una foto: mal formada, demasiado grande o que no es imagen. El score top-1, la baja confianza y el PSI se explican en «El modelo sin labels».

Las dos capas de arriba existen en cualquier servicio. Las tres de abajo son de ML. Y la regla que las ordena es incómoda: cuanto más abajo, más lenta la señal y más cerca de lo que importa. Lo que de verdad importa es si la sugerencia fue correcta, y eso solo lo dice un label (la categoría correcta), que llega tarde.

Las cinco capas del monitoreo de Alba, de arriba abajo. Infraestructura: nodos, GPU y pods listos; avisa en segundos. Servicio: p99, errores 5xx y fila de Triton; segundos a minutos. Datos: bytes de las fotos por source y tasas de 400, 413 y 415; minutos. Modelo: score top-1, tasa de baja confianza y PSI de las categorías; minutos a un día. Negocio: aceptación, recategorización de moderación y holdout; horas a semanas. Las dos de arriba son de cualquier servicio y las tres de abajo son de ML. Una flecha a la izquierda dice que hacia abajo la señal es más lenta y más cercana a lo que importa: si la sugerencia fue correcta. MÁS RÁPIDA MÁS CERCA DE LO QUE IMPORTA Infraestructura SEGUNDOS nodos, GPU, pods listos Servicio SEG. A MIN p99, 5xx, fila de Triton Datos MINUTOS bytes por source; 400, 413, 415 Modelo MIN A 1 DÍA score top-1, baja confianza, PSI Negocio HORAS A SEMANAS aceptación, moderación, holdout cualquier servicio propias de ML
Las cinco capas de Alba. Arriba, señales que llegan en segundos y no saben nada de calidad; abajo, señales que dicen la verdad pero tardan días o semanas.

La app nueva: una falla silenciosa con números

El caso del martes, con números de ejemplo. El viernes sale una versión nueva de la app del celular que procesa distinto las fotos: más compresión y un filtro de contraste. El backend la sigue mandando con source=mobile. Así se ve en cada capa:

CapaLo que se ve¿Suena algo?
Infraestructuranadano
Servicioel p99 de un pod del gateway, ≈ 69 ms en el pico de diseño, y 5xx en el 0.1 % del SLOno
Datoslas fotos de mobile bajan de ≈ 210 KB a ≈ 140 KB de mediana, en minutosno hay alerta: se ve en el dashboard, si alguien mira
Modelola tasa de baja confianza (las fotos en que el modelo duda: su probabilidad más alta queda abajo de 0.3) sube de 4 % a 5.5 % del totalno: la alerta pide el doble, ≈ 8 %
Negocio6 días después, la aceptación de mobile (cuántas veces quien vende elige una de las sugerencias) cae de 70.1 % a 66.2 % semana contra semanasí: un ticket

La señal rápida (los bytes) estaba ahí desde el primer minuto, pero no prueba nada: una foto más chica no tiene por qué ser peor. La señal lenta (la aceptación) sí prueba que algo empeoró, pero tardó casi una semana. Monitorear un modelo es vivir entre esas dos: usar las rápidas para sospechar y las lentas para confirmar.

Y fíjate qué no se debe hacer con ese ticket: reentrenar. El modelo no tiene la culpa; la tiene un cambio en quien llama. Reentrenar le enseñaría a convivir con un bug que se arregla en la app. Lo verás en «Del aviso a la decisión».

03

Las señales de servicio de Alba

Esencial

Alba's service signals

Las dos capas de arriba se vigilan como cualquier servicio web, con recetas conocidas.

Señales doradas, RED y USE

Las señales doradas (golden signals), del libro de SRE de Google (Site Reliability Engineering, la disciplina de mantener servicios en pie), son cuatro preguntas para cualquier servicio:

  • Latencia: cuánto tarda. En Alba, el p99 del histograma classifier_request_latency_seconds («latencia de cada request del clasificador, en segundos»), contra los 200 ms del SLO.
  • Tráfico: cuánto le piden. Las requests por segundo, ≈ 116 en promedio y ≈ 350 en el pico.
  • Errores: cuántas fallan. La fracción de 5xx (los códigos de error del servidor) sobre las requests que no son 4xx (los 4xx son culpa de quien llama: no cuentan).
  • Saturación: qué tan lleno está: qué tan cerca del punto en que empieza a hacer esperar.

Dos recetas más cortas dicen lo mismo desde dos ángulos. RED (rate, errors, duration: tasa, errores, duración) es para cada servicio: el gateway y Triton tienen cada uno su tasa, sus errores y su latencia. USE (utilization, saturation, errors: utilización, saturación, errores) es para cada recurso: cada GPU, cada nodo, cada disco.

Saturación: la fila, no el porcentaje

La tentación es medir la saturación con la utilización de la GPU: «está al 100 %, está llena». No es así. La utilización dice qué fracción del tiempo la GPU tuvo algo que hacer, no si alguien esperaba. Lo viste en «Qué tan rápido y cuánto: latencia y throughput»: la saturación se nota en el tiempo de espera en la fila.

Por eso la señal de saturación de Alba es la espera media en la fila de Triton. Triton lleva dos contadores (números que solo suben): los microsegundos que todas sus requests pasaron en la fila, acumulados, y cuántas requests terminó bien. La espera media en una ventana es el cociente de lo que creció cada uno:

Espera media en la fila de Triton
W=DqNok÷1,000
donde
Dq
los microsegundos que las requests pasaron en la fila durante la ventana: lo que creció el contador nv_inference_queue_duration_us, en µs
Nok
las requests que Triton terminó bien en la misma ventana: lo que creció nv_inference_request_success, en requests
÷1,000
pasa de µs a ms
W
la espera media en la fila, en ms

Un minuto del pico, con números de ejemplo: el contador de la fila crece Dq = 42,000,000 µs y el de éxitos Nok = 21,000 (350 por segundo × 60). La espera media es 42,000,000 ÷ 21,000 = 2,000 µs = 2 ms. Tranquilo.

Con esa misma espera trabaja KEDA, el programa que escala Triton: busca que la espera media de los últimos 2 minutos quede en 10 ms, con 2 réplicas (copias de Triton) como mínimo y 4 como máximo. Si la espera pasa de 20 ms durante 10 minutos, el doble de su objetivo, salta el warning TritonQueueTimeHigh («la espera en la fila de Triton está alta»): KEDA no está alcanzando. La utilización tiene su propio warning, GPUSaturated («GPU saturada»), si una GPU pasa de 85 % durante 15 minutos. Se mide por GPU, sin sumar: el promedio de una al 100 % y otra al 40 % da un 70 % tranquilo que esconde a la que se ahoga.

04

Una alerta bien hecha

Esencial

A well-made alert

Una regla de alerta es una regla que Prometheus evalúa cada cierto tiempo: si una expresión da verdadero el tiempo suficiente, avisa a alguien. Escribirla es fácil. Escribirla bien es lo que separa a una guardia que duerme de una que deja de creer en sus alertas.

La anatomía

Cada alerta de Alba lleva seis cosas:

  1. Un nombre que es el síntoma: ClassifierHighP99Latency («el p99 de la latencia del clasificador está alto») dice qué siente el usuario, no qué pieza falló. Se alerta por síntomas; las causas se buscan después.
  2. Una condición y una ventana, que salen del SLO: «p99 > 200 ms».
  3. Un for: cuánto tiempo debe sostenerse la condición antes de disparar.
  4. Una severidad: page, warning o ticket.
  5. Un dueño: una rotación de personas, nunca «el equipo».
  6. Un runbook: el documento que dice qué revisar y qué hacer, enlazado en la alerta misma.

Y una prueba: si no hay acción posible, no es un page.

Las tres severidades

SeveridadQué significa en AlbaA quién le llega
pageel usuario está afectado ahora y alguien puede arreglarlo ahoraa la persona de guardia, que la reconoce en ≤ 5 minutos, de día o de noche
warninguna causa que anticipa un pageal canal del equipo, en horario de trabajo
ticketla calidad del modelo y las tendenciasa la cola del equipo de ML; se revisa en la semana

La guardia es una rotación semanal entre las 5 personas del equipo; en los ejemplos, la que está de guardia es Marta. Fíjate en lo que la tabla deja fuera de su teléfono: la calidad del modelo. Nadie debería despertarse a las 3 de la mañana porque subió el PSI. Un cambio en el modelo se entiende mirando muestras y datos, con calma, y en Alba el usuario tiene un respaldo: si no hay sugerencia, Ana, la vendedora de los ejemplos, elige la categoría en el selector manual.

Las alertas de Alba

SeveridadAlertaCondición
pageClassifierHighP99Latency
(p99 alto)
p99 > 200 ms durante 10 min
pageClassifierErrorBudgetFastBurn
(el presupuesto se quema rápido)
el presupuesto se gasta 14.4× más rápido de lo permitido, en 1 h y en 5 min
pageTritonNotReady
(Triton no está listo)
menos de 2 pods listos del Triton de la release vigente (triton-v14 hoy) durante 5 min
pageALB5xx
(5xx del ALB)
los 5xx que pone el propio ALB pasan de 0.5 % del total en 5 min (RequestCount más esos 5xx; en CloudWatch)
warningTritonQueueTimeHigh
(fila de Triton alta)
espera en la fila > 20 ms durante 10 min
warningGPUSaturated
(GPU saturada)
una GPU > 85 % durante 15 min
warningLogsStale
(logs atrasados)
no llega un archivo de log nuevo a S3 en 30 min
ticketClassifierErrorBudgetSlowBurn
(el presupuesto se quema lento)
6× en 6 h y en 30 min
ticketClassifierLowConfidenceSpike
(pico de baja confianza)
la baja confianza pasa del doble de su promedio de 7 días durante 30 min
ticketdrift de categoríasPSI > 0.2 tres días seguidos
ticketcaída de aceptación> 3 puntos semana contra semana
ticketMonitoringJobStale
(job de monitoreo atrasado)
el job diario no publica en 26 h

La alerta del p99 y sus 10 minutos ya los viste en «Promedios, medianas y percentiles». Las de errores van por burn rate, lo que sigue.

for: que dure antes de sonar

Sin for, una regla dispara en la primera evaluación que da verdadero. Un deploy reinicia un pod, un minuto sale lento, y suena. Con for: 10m (10m es «10 minutos» en la notación de Prometheus), la alerta queda pendiente mientras la condición se cumple y solo dispara si sigue cumpliéndose 10 minutos después. Si en medio una evaluación da falso, el reloj vuelve a cero. El costo: 10 minutos más tarde en avisar. Por eso el for se elige con el SLO: el p99 de Alba se vigila en ventanas de 5 minutos, y dos ventanas seguidas malas ya no son un pico.

Tráfico bajo: un error no es una tasa

A las 4 de la mañana, en un minuto pueden llegar unas pocas decenas de requests. Si en una ventana hay 20 requests y una falla, la tasa es 5 %, cincuenta veces el 0.1 % permitido. Una regla que solo mira la fracción despertaría a Marta por una sola request. La defensa es pedir volumen además de fracción: la alerta de baja confianza de Alba exige más de 1 request por segundo en su ventana. Es la misma idea del canary de «Rollout seguro» (la versión nueva recibe primero una parte chica del tráfico): no se juzga hasta que junta un mínimo de requests.

La serie que no está

Si un pod del gateway muere, sus métricas desaparecen: no valen cero, simplemente no hay serie. Y una regla que divide errores entre requests no da «verdadero» ni «falso» sobre una serie que no existe: no da nada, y no dispara. El servicio caído tiene el dashboard más tranquilo del mundo.

Tres defensas:

  • Mirar si se pudo leer: Prometheus guarda para cada pod que lee la serie up, que vale 1 si la lectura funcionó y 0 si no. up == 0 sí da resultado cuando el pod no contesta, mientras Prometheus lo siga teniendo en su lista. Si el pod desaparece del todo (Kubernetes lo borra y ya no aparece en el Service, el objeto que lista los pods que reciben tráfico), su up también desaparece: por eso hacen falta las otras dos defensas.
  • Preguntar por la ausencia: absent(serie) da 1 justo cuando la serie no existe.
  • Alertar desde quien espera: TritonNotReady no le pregunta a Triton si está bien. Cuenta, desde Kubernetes (con kube-state-metrics, el programa que publica el estado de los objetos del clúster como métricas), cuántos pods de triton-v14 están listos. Y ALB5xx mira desde el ALB: si todos los gateways salen del balanceador, el ALB contesta 503 él mismo y el gateway no cuenta nada, porque nadie le llegó. Lo viste en «La request en vivo».

Reglas de grabación: precalcular lo caro

Algunas expresiones son caras: la tasa de errores de las últimas 6 horas suma millones de muestras. Si cada alerta la recalcula en cada evaluación, Prometheus trabaja de más. Una regla de grabación (recording rule) la calcula cada cierto tiempo (en Alba, cada minuto) y guarda el resultado como una serie nueva, con un nombre propio. Alba graba la tasa de errores en cuatro ventanas (classifier:error_ratio:rate5m, …rate30m, …rate1h y …rate6h) y la tasa de baja confianza en 30 minutos. El nombre sigue una costumbre de tres partes: nivel (classifier), métrica (error_ratio) y operación (rate1h).

Alertmanager: de la alerta a la persona

Prometheus decide que una alerta suena. Quién se entera y cómo lo decide el Alertmanager, un programa aparte que en Alba vive en el namespace monitoring (el espacio con nombre del clúster donde corre todo el monitoreo). Hace cuatro cosas:

  • Agrupa: las alertas de un mismo incidente llegan en una sola notificación. Alba agrupa por nombre de alerta y por namespace.
  • Deduplica: si hay dos Prometheus iguales por seguridad, la misma alerta llega dos veces; Alertmanager manda una.
  • Inhibe: calla las alertas que son consecuencia de otra. Si TritonNotReady está sonando, los warning de la fila de Triton se callan: claro que la fila está mal, si no hay Triton.
  • Silencia: durante un mantenimiento anunciado, alguien pone un silencio con hora de fin.
De la métrica a la persona: el monitoreo de Alba · El camino de una señal en Alba: de la métrica del pod a la persona que se entera. Toca cada caja; los recorridos siguen un incidente de errores de noche y un PSI que sube.
  • monitoreo-diario · 01:00 UTC
    El job diario: pasa el log a Parquet, calcula el PSI de las ≈ 30 categorías padre y la aceptación por slice, y publica cada resultado como gauge (una métrica que sube y baja). Tarda ≈ 20 min.
  • gateway y Triton · /metrics
    Cada pod lleva sus métricas en memoria y las expone en /metrics (el gateway en el puerto 8080, Triton en el 8002). Si el pod muere, sus series desaparecen.
  • ALB · la entrada
    El balanceador. Ve lo que el gateway no: si todos los gateways salen de su lista, contesta 503 él mismo.
  • Pushgateway · último valor
    Guarda lo que el job le empuja hasta que alguien lo borre, más push_time_seconds, la hora del último envío. Por eso existe MonitoringJobStale (26 h).
  • Prometheus · cada 15 segundos
    Lee /metrics de cada pod cada 15 segundos (lo declaran un ServiceMonitor para Triton y un PodMonitor para el gateway) y guarda 15 días. Para cada pod que lee, guarda también up: 1 si pudo leer, 0 si no.
  • Grafana · 4 dashboards
    Los dashboards: servicio, Triton y GPU, modelo y negocio. Consulta a Prometheus; no decide nada.
  • CloudWatch · alarma ALB5xx
    El servicio de métricas de AWS. La alarma ALB5xx es un page si los 5xx del propio ALB pasan de 0.5 % del total en 5 min. El total suma RequestCount y esos 5xx, porque RequestCount no cuenta las requests que no llegaron a un destino.
  • reglas · grabación y alerta
    Las reglas de grabación precalculan las tasas de error (5 min, 30 min, 1 h, 6 h) y la baja confianza; las reglas de alerta las comparan con su umbral, su for y su severidad.
  • Alertmanager · agrupa e inhibe
    Alertmanager vive en el namespace monitoring, con Prometheus y Grafana. Agrupa por alerta y namespace, deduplica, calla los warning de Triton mientras TritonNotReady suena y respeta los silencios de mantenimiento.
  • cola de ML · ticket
    Los tickets: calidad del modelo y tendencias. Se revisan en la semana, en horario.
  • canal del equipo · warning
    Los warning: causas que anticipan un page, como la fila de Triton arriba de 20 ms. Se miran en horario de trabajo.
  • Marta · page · ≤ 5 min
    La persona de guardia de la semana. Recibe solo los page y los reconoce en ≤ 5 minutos, de día o de noche.
Para ir más hondoLa regla, como la escribe Alba

Las reglas viven en el repositorio de despliegue, como objetos PrometheusRule que carga el operador de Prometheus (el programa que instala y configura Prometheus en Kubernetes): cambiar una alerta es un PR que otra persona revisa. Por eso TritonNotReady cambia en el mismo PR que la release: cuando entre la 15, mirará triton-v15.

Una parte de la PrometheusRule de Alba, como ilustración (necesita Prometheus): la regla de grabación de 1 hora y la alerta rápida de errores.

YAML
groups:
  - name: classifier-slo
    rules:
      - record: classifier:error_ratio:rate1h      # 5xx ÷ requests sin 4xx, en 1 h
        expr: |
          sum(rate(classifier_requests_total{status=~"5.."}[1h]))
            / sum(rate(classifier_requests_total{status!~"4.."}[1h]))
      - alert: ClassifierErrorBudgetFastBurn
        expr: |
          classifier:error_ratio:rate1h > (14.4 * 0.001)
          and classifier:error_ratio:rate5m > (14.4 * 0.001)
        labels:                                       # etiquetas de la alerta, no labels de entrenamiento
          severity: page
        annotations:
          summary: "El presupuesto de errores se gasta 14.4× más rápido de lo permitido"
          runbook_url: "https://runbooks.alba.example/classifier/error-budget-burn"
05

Burn rate: alertar con el presupuesto

Esencial

Burn rate: alerting with the budget

¿Cuántos errores son demasiados? La respuesta ingenua es un umbral fijo: «más de 1 % de 5xx en 5 minutos». Tiene dos problemas. Cinco minutos al 1.1 % se comen una parte diminuta del mes (≈ 0.13 % del presupuesto, con la fórmula de abajo) y despiertan a alguien igual. Y un 0.5 % sostenido toda una semana nunca dispara, aunque se coma todo el presupuesto del mes y un poco más: 0.5 % es 5 veces el 0.1 % permitido, y una semana es 168 de las 720 horas del mes, así que gasta 5 × 168 ÷ 720 ≈ 117 % del presupuesto. El umbral fijo no sabe cuánto daño hace un error; el presupuesto sí.

La fórmula

El burn rate (velocidad de gasto) es qué tan rápido se gasta el presupuesto comparado con el ritmo que lo agotaría justo al final de los 30 días. En «Probabilidad para sistemas que fallan» lo calculaste para un deploy malo: con 5 % de errores contra un presupuesto de 0.1 %, se gasta 50 veces más rápido. Aquí van las mismas letras de esa lección (S, p, R, B, F, f), con un cambio: las horas de la ventana son t, y no h, para no confundirlas con la unidad.

Burn rate y lo que gasta una ventana
β=p1−S
f=β×tV
ta=Vβ
donde
S
el SLO de disponibilidad, como fracción: 0.999 en Alba
1−S
el presupuesto como fracción de las requests: 0.001
p
la fracción de requests con error del servidor en la ventana (5xx ÷ requests sin 4xx), como fracción
β
el burn rate, en veces: 1× gasta el presupuesto justo en los 30 días
t
la duración de la ventana de la alerta, en horas
V
la ventana del SLO, en horas: 30 días = 720 h
f
la fracción del presupuesto del mes que se gasta en esas t horas
ta
las horas que tardaría en agotarse el presupuesto completo a ese ritmo
R
las requests al día: ≈ 10,000,000 en Alba
B
el presupuesto del mes, en requests: B=(1−S)×R×30 = 300,000 (es una letra de la cuenta, no la B de bytes)
F
las requests con error en la ventana, F=R÷24×t×p. No la confundas con f: F cuenta requests y f es la fracción del presupuesto, f=F÷B

Las tres líneas dicen lo mismo de tres formas. Si β = 1, la fracción p es justo el 0.1 % y el presupuesto dura las 720 horas. Si β = 2, dura la mitad. Y en una ventana de t horas se gasta la parte t÷V del mes, multiplicada por β.

De dónde salen 14.4× y 6×

Los números de Alba vienen del libro de trabajo de SRE de Google (The Site Reliability Workbook), y salen al revés: primero se decide cuánto presupuesto se tolera perder antes de avisar, y de ahí se despeja β. Despejando la segunda línea, β=f×V÷t:

  • Page: perder 2 % del presupuesto en 1 hora. β = 0.02 × 720 ÷ 1 = 14.4.
  • Ticket: perder 5 % en 6 horas. β = 0.05 × 720 ÷ 6 = 6.
Las dos alertas de errores de AlbaLa cuenta
Presupuesto como fracción, 1−SS = 0.999
1 − 0.999
0.001
Requests por hora, R÷24R ≈ 10,000,000 al día
10,000,000 ÷ 24
≈ 416,667
Presupuesto del mes, B=(1−S)×R×30
0.001 × 10,000,000 × 30
300,000
Fracción de errores del page, p=β×(1−S)β = 14.4
14.4 × 0.001
1.44 %
Errores en la hora, F=R÷24×t×pt = 1 h
416,667 × 1 × 0.0144
≈ 6,000
Presupuesto gastado, f=β×t÷VV = 720 h
14.4 × 1 ÷ 720 (= 6,000 ÷ 300,000)
2 %
Se agotaría en, ta=V÷β
720 ÷ 14.4
50 h
Fracción de errores del ticket, pβ = 6
6 × 0.001
0.6 %
Errores en 6 horas, Ft = 6 h
416,667 × 6 × 0.006
≈ 15,000
Presupuesto gastado, f
6 × 6 ÷ 720 (= 15,000 ÷ 300,000)
5 %
Se agotaría en, ta
720 ÷ 6
120 h = 5 días
Resultado
El page suena cuando una hora entera va al 1.44 % de errores: ≈ 6,000 requests sin sugerencia, 2 % del mes, y a ese ritmo el mes se acaba en 50 horas. El ticket, cuando 6 horas van al 0.6 %.

El libro de SRE pone el de 6× como page. Alba lo manda a ticket porque tiene un respaldo: si el clasificador falla, Ana elige la categoría en el selector manual. Un 0.6 % de errores durante 6 horas se arregla en horario; un servicio sin respaldo, como un pago, lo dejaría en page. El libro tiene además un tercer nivel, 1× en 3 días (ticket), que Alba no usa. Sin él, el goteo de 0.5 % de toda una semana (5×) no llega al 6× y ninguna alerta de Alba lo ve. El último ejercicio lo calcula.

Dos ventanas: la larga confirma, la corta apaga

Cada alerta de burn rate mira dos ventanas a la vez, y dispara solo si las dos pasan el umbral: 1 hora y 5 minutos para el page, 6 horas y 30 minutos para el ticket. La corta mide 1/12 de la larga, la proporción que recomienda el libro, para bajar en minutos. Es una alerta multiventana (multiwindow, multi-burn-rate alert).

¿Para qué dos? La ventana larga es la que confirma: un pico de 2 minutos no mueve el promedio de una hora, así que no despierta a nadie. Pero tiene memoria: después del arreglo, la hora siguiente sigue cargando los errores de antes, y la alerta seguiría sonando media hora con el servicio ya sano. La ventana corta es la que apaga: 5 minutos después del arreglo vuelve a la normalidad, y como la regla pide las dos, la alerta se calla.

Un incidente de ejemplo con 3 % de errores, burn rate de 30, durante los primeros 40 minutos. La gráfica muestra el burn rate medido en dos ventanas contra el tiempo, de 0 a 100 minutos, con una línea horizontal en el umbral de 14.4. Antes y después del incidente, el supuesto del ejemplo es un fondo de 0.1 % de errores, el tope del SLO: burn rate de 1. La ventana de 5 minutos sube a 30 en 5 minutos, se queda ahí y vuelve a 1 cinco minutos después del arreglo. La ventana de 1 hora sube despacio, cruza 14.4 en el minuto 27, llega a ≈ 20 y no baja de 14.4 hasta el minuto 72. El page suena solo mientras las dos están arriba del umbral: del minuto 27 al 42. ventana de 1 h ventana de 5 min INCIDENTE 3 % ARREGLO PAGE 14.4× 30× 0 0 20 40 60 80 100 minutos desde que empieza el incidente sola, la de 1 h sonaría hasta el 72 Suena con las dos arriba; se apaga con la corta.
Un incidente de ejemplo: 3 % de errores (β = 30) durante 40 minutos, con un fondo de 0.1 % (el tope del SLO) antes y después. La ventana de 1 hora cruza 14.4× en el minuto 27 y, sola, seguiría arriba hasta el 72; la de 5 minutos baja enseguida. El page suena mientras las dos están arriba: del minuto 27 al 42.
Para ir más hondoEl mismo incidente, minuto a minuto

Supone el mismo número de requests cada minuto, así que la fracción de una ventana es el promedio de sus minutos:

Python
S = 0.999                        # el SLO: 99.9 % sin error del servidor
p = [0.001] * 150                # fracción con error, minuto a minuto
for minuto in range(60, 100):    # un incidente: 3 % de errores por 40 min
    p[minuto] = 0.03

def burn(fin, largo):            # β de la ventana de `largo` minutos que acaba en `fin`
    ventana = p[fin - largo + 1 : fin + 1]
    return sum(ventana) / largo / (1 - S)

sonando = False
for minuto in range(60, 150):
    larga, corta = burn(minuto, 60), burn(minuto, 5)
    ahora = larga > 14.4 and corta > 14.4
    if ahora != sonando:
        estado = "SUENA" if ahora else "se apaga"
        print(f"min {minuto - 60:>2}: {estado:8}  1 h = {larga:4.1f}×  5 min = {corta:4.1f}×")
        sonando = ahora
print(f"solo con la de 1 h se apagaría en el min {next(m - 60 for m in range(100, 150) if burn(m, 60) <= 14.4)}")
Salida
min 27: SUENA     1 h = 14.5×  5 min = 30.0×
min 42: se apaga  1 h = 20.3×  5 min = 12.6×
solo con la de 1 h se apagaría en el min 72

Suena en el minuto 27 y se apaga en el 42, 2 minutos después del arreglo (el incidente ocupa los minutos 0 a 39), con la ventana de 1 hora todavía en 20×. Son los mismos minutos de la figura. Sin la ventana corta, Marta vería la alerta sonar media hora más con todo ya bien.

¿Y si el incidente es peor? Con p = 100 % (todo falla), β = 1 ÷ 0.001 = 1,000, y la ventana de 1 hora cruza 14.4× en 14.4 ÷ 1,000 = 0.0144 horas: ≈ 0.9 minutos de errores. En la práctica suena en uno o dos minutos, porque Prometheus lee cada 15 segundos y las reglas se evalúan cada minuto. La alerta se adapta sola: cuanto más grave, más rápido suena.

Burn rate: qué tan rápido se va el presupuestoCalculadora

Elige el SLO, la fracción de errores y la ventana. La calculadora aplica β=p÷(1−S), f=β×t÷V con V = 720 h, ta=V÷β, B=(1−S)×R×30 y F=R÷24×t×p. Arranca con el page de Alba: 1.44 % de errores durante 1 hora.

Burn rate, ββ=p÷(1−S); el page de Alba pide más de 14.4 ×, el ticket más de 6 ×14.4×
Presupuesto gastado en la ventana, ff=β×t÷V, con V = 720 h (30 días); tope en 100 %2.0 %
Requests con error en la ventana, FF=R÷24×t×p6,000
Presupuesto del mes, B (requests)B=(1−S)×R×30300,000
Horas para agotar el presupuesto, tata=V÷β50.0

Supone el mismo tráfico todas las horas. Con p = 0.1 % y S = 99.9 %, β = 1: el presupuesto dura justo los 30 días.

Arranca con el page de Alba: 1.44 % de errores en 1 hora. Sube p a 5 % (el deploy malo de «Probabilidad para sistemas que fallan») y mira cómo el mes se agota en 14.4 horas. Luego pon p = 0.6 % y t = 6 h: es el ticket.

06

El modelo sin labels: baja confianza, score y PSI

Esencial

The model without labels: low confidence, score and PSI

En el momento de la request nadie sabe si la sugerencia fue correcta. Lo que sí se sabe es lo que el modelo contestó y cómo venía la foto. Con eso se arman los proxies de calidad (proxy metrics): señales sin labels que avisan «algo cambió» en minutos. Ninguna prueba que el modelo empeoró. Sirven para sospechar, abrir un ticket, mirar muestras y mandar a etiquetar.

Alba tiene tres:

  • El score top-1: la probabilidad de la categoría que quedó en primer lugar. El histograma classifier_top1_score («score top-1 del clasificador») lo cuenta por model_version, con 10 bordes (0.1, 0.2, …, 1.0): para cada borde, cuántas fotos tuvieron un top-1 menor o igual.
  • La tasa de baja confianza: qué fracción de las fotos tiene top-1 menor que 0.3.
  • El PSI de las categorías: qué tanto cambió la mezcla de categorías predichas.

La tasa de baja confianza

Alba llama «foto dudosa» a la que tiene top-1 < 0.3, el umbral que viste en «Qué es un modelo». En un día normal son ≈ 4 % de las fotos: ≈ 400 mil de los ≈ 10 millones. La tasa sale de dos contadores del histograma del score, en una ventana de 30 minutos:

Tasa de baja confianza
c=NbajaNtotal
ticket si c>2×c7
donde
Nbaja
las requests de la ventana con top-1 menor que 0.3: lo que creció el bucket le="0.3" del histograma del score (le es less or equal, «menor o igual»: cuenta también las de 0.3 exacto, una diferencia que no se nota)
Ntotal
todas las requests de la ventana: lo que creció el total del histograma (_count)
c
la tasa de baja confianza, como fracción
c7
el promedio de c en los últimos 7 días, como fracción

La alerta ClassifierLowConfidenceSpike abre un ticket si c > 2 × c7 durante 30 minutos y además llega más de 1 request por segundo. Se compara contra su propio promedio, no contra un número fijo, porque la tasa normal se mueve con las temporadas: una campaña de bicicletas la sube un poco y eso no es una falla.

La baja confianza en media hora de tráfico promedioLa cuenta
Requests en 30 min, Ntotal≈ 116 por segundo × 1,800 segundos
116 × 1,800
208,800
Fotos dudosas en un día normal, Nbajatasa normal ≈ 4 %
208,800 × 0.04
≈ 8,352
Tasa, c=Nbaja÷Ntotal
8,352 ÷ 208,800
4 %
Promedio de 7 días, c77 días normales como este
= la tasa normal
≈ 4 %
Umbral, 2×c7
2 × 0.04
≈ 8 %
Fotos dudosas para dispararmás que 2×c7×Ntotal
0.08 × 208,800
> 16,704
Volumen mínimomás de 1 request por segundo en 30 min
1 × 1,800
> 1,800 requests
Resultado
En media hora normal hay ≈ 8 mil fotos dudosas; el ticket pide más de ≈ 16.7 mil, sostenido 30 minutos. Con 208,800 requests, el azar mueve la tasa apenas ± 0.08 puntos (es el margen de una tasa de «Cuánto ruido tiene una tasa», más abajo: 1.96 × √(0.04 × 0.96 ÷ 208,800)): un salto al doble no es ruido.

La tasa se calcula con una regla de grabación, classifier:low_confidence_share:rate30m («la fracción de baja confianza en 30 minutos»), cada minuto.

Para ir más hondoPor qué se graba, y la expresión

¿Por qué grabarla? Porque la alerta la compara con su promedio de 7 días. Promediar 7 días de la expresión cruda en cada evaluación obligaría a Prometheus a releer una semana de buckets cada vez; promediar la serie grabada, una muestra por minuto, es barato. Por eso Prometheus guarda 15 días en Alba: la alerta necesita al menos 7.

Así se ve, como ilustración, la expresión que graba esa regla (es PromQL, el lenguaje de consultas de Prometheus que presenta «La request en vivo»):

sum(rate(classifier_top1_score_bucket{le="0.3"}[30m]))
  / sum(rate(classifier_top1_score_count[30m]))

El PSI del día, contra qué y cuánto tiempo

El PSI (Population Stability Index, índice de estabilidad de la población) mide qué tanto se movió una distribución. Parte los datos en bins (las casillas de un histograma; aquí, cada bin es una categoría padre) y suma, bin por bin, la diferencia entre la proporción de hoy y la de la referencia, multiplicada por el logaritmo de su cociente. La cuenta completa y cómo se lee están en «Comparar distribuciones: cómo se mide el drift»; aquí importa lo operativo.

Alba lo calcula una vez al día sobre la mezcla de categorías predichas, agrupadas en sus ≈ 30 categorías padre (las ramas de arriba del árbol, como «Calzado», que contiene a «Calzado › Tenis»). Así lo hace también el canary de «Rollout seguro», que mide el PSI de cada hora mientras entra una versión nueva: allí, con 500 bins y una hora de datos, el puro azar daba un PSI alto. Con un día entero de fotos ese ruido es chico, pero agrupar igual hace que las dos cuentas se lean igual y que un slice chico no se infle de azar.

En una semana normal, el PSI de cada día sale ≈ 0.002. La lectura de costumbre: menos de 0.1 es estable; de 0.1 a 0.25, un cambio moderado; más de 0.25, uno grande. Alba pone su umbral en 0.2.

La pregunta difícil es contra qué se compara. Es la referencia del drift, y cada opción ve una cosa y se pierde otra («Comparar distribuciones: cómo se mide el drift» las compara todas):

ReferenciaQué pregunta respondeQué se pierde
El mes con que se entrenó el champion (su snapshot, la copia congelada de los datos: ds-2026-09-01 para la 14)¿ve algo que no aprendió?si el mundo se movió para siempre, suena sin parar
Las 4 semanas previas¿cambió de golpe?un cambio lento nunca se ve: cada semana se parece a la anterior

Alba usa las dos: las 4 semanas previas para la alerta, y el mes del snapshot del champion para el reporte mensual, que ve los cambios lentos.

Y el cuánto tiempo: el ticket se abre si el PSI pasa de 0.2 tres días seguidos. Un solo día raro (un festivo, una campaña) no basta. En «Comparar distribuciones: cómo se mide el drift», en «Chi-cuadrado y las falsas alarmas», viste cuánto rinde pedir que dure: si una prueba da falsa alarma el 5 % de los días y los días fueran independientes, tres seguidos pasan 1 vez de cada 8,000 (0.05 × 0.05 × 0.05 = 1 ÷ 8,000). Allí también está por qué Alba usa el PSI y no un p-value (la probabilidad de ver un cambio así por puro azar): con millones de fotos, la prueba KS da p ≈ 0 por cualquier cambio diminuto.

Para ir más hondoLa regla de los tres días, en Python

La regla, día por día:

Python
psi = {                          # PSI diario de las 30 categorías padre
    "11-03": 0.002, "11-04": 0.24, "11-05": 0.003, "11-06": 0.21,
    "11-07": 0.23, "11-08": 0.004, "11-09": 0.22, "11-10": 0.26,
    "11-11": 0.29, "11-12": 0.31,
}
UMBRAL, DIAS = 0.2, 3            # la regla de Alba: > 0.2 tres días seguidos

racha = 0
for dia, valor in psi.items():
    racha = racha + 1 if valor > UMBRAL else 0
    marca = "  <- ticket" if racha == DIAS else ""
    print(f"{dia}  PSI {valor:.3f}  racha {racha}{marca}")
Salida
11-03  PSI 0.002  racha 0
11-04  PSI 0.240  racha 1
11-05  PSI 0.003  racha 0
11-06  PSI 0.210  racha 1
11-07  PSI 0.230  racha 2
11-08  PSI 0.004  racha 0
11-09  PSI 0.220  racha 1
11-10  PSI 0.260  racha 2
11-11  PSI 0.290  racha 3  <- ticket
11-12  PSI 0.310  racha 4

Dos días sueltos arriba de 0.2 no abren nada; tres seguidos, sí, y abren un solo ticket aunque la racha siga.

07

Los labels que llegan tarde

Esencial

Labels that arrive late

La pregunta que de verdad importa, «¿acertó?», solo la contesta un label. En Alba los labels llegan de tres fuentes, cada una con su retraso y su trampa. Son labels demorados, como viste en «Datos y etiquetas».

Tres fuentes, tres retrasos

FuenteQué esRetrasoSu trampa
Aceptaciónsi quien vende eligió una de las 5 sugerenciasminutos a horasestá sesgada por lo que el modelo mostró
Moderacióncuando un moderador recategoriza una publicación ya hechadíassolo mira lo que alguien reportó o revisó
Holdoutla categoría que eligió a mano el ≈ 1 % que nunca ve sugerencias1 a 2 meses (madura a los 30 días)la sugerencia no la sesga, pero tarda
Cuándo llega cada label de una foto subida hoy, en una línea de tiempo que va de la foto a dos meses. La aceptación llega entre minutos y horas, y está sesgada: quien vende tiende a aceptar lo que le mostraron. La recategorización de moderación llega en días y solo cubre lo que alguien revisó. El holdout, el 1 % de vendedores que nunca ve sugerencias, se cree hasta los 30 días y da la exactitud real en uno o dos meses; es la medida sin sesgo de la sugerencia. CUÁNDO LLEGA CADA LABEL foto min horas días 1 mes 2 meses Aceptación rápida, pero sesgada: se acepta lo que se mostró Moderación en días, y solo lo que alguien reportó o revisó Holdout ≈ 1 % sin sugerencias: tarda, pero es la medida limpia MADURA A LOS 30 DÍAS
Cuándo llega cada label de una foto subida hoy. La aceptación llega primero y es la más sesgada; el holdout llega al final y es la medida limpia.

La aceptación, y por qué no basta

La tasa de aceptación es, de las publicaciones donde la pantalla pintó las sugerencias, la fracción cuya categoría se eligió por la vía «sugerencia». Su base es ≈ 70 %, y la mide el backend con suggestion_shown y category_selected (la vía puede ser sugerencia, búsqueda o el árbol de categorías).

La aceptación es la señal más rápida de negocio, pero miente un poco. Quien vende tiende a aceptar lo que le pusieron enfrente: si el modelo sugiere «Calzado › Tenis» para unos zapatos de vestir, mucha gente lo deja. Es el feedback loop de «Datos y etiquetas»: contra lo que elige quien vende, el modelo parece acertar ≈ 95 %, cuando de verdad acierta ≈ 85 %. Diez puntos de optimismo.

El holdout: la medida limpia

La defensa es una muestra que no depende del modelo: el holdout, ≈ 1 % de las cuentas de vendedor (elegidas por el hash de su seller_id, como viste en «Datos y etiquetas») que nunca ve sugerencias: ≈ 25 mil publicaciones al día, ≈ 750 mil al mes. Ahí la persona elige sola, así que comparar contra su elección el top-1 del champion da la exactitud sin la huella de la sugerencia (quien vende también se equivoca: eso lo mide la muestra al azar): ≈ 85 %, con ± 0.1 punto de ruido. La que dice el examen fijo del gate, el golden set, también es ≈ 85 %: la brecha offline–online de Alba hoy es casi cero. Si un mes el holdout cae a 82 % y el golden set sigue en 85 %, el mundo ya no se parece al examen.

El precio del holdout es el tiempo: un label se cree hasta que pasan 30 días sin corrección de moderación (la regla de maduración), así que la medida limpia de este mes llega en uno o dos meses.

Cuánto ruido tiene una tasa

Una caída de 3 puntos en la aceptación, ¿es real o es azar? Depende de cuántas publicaciones la midieron. Es el intervalo de confianza de «Ruido, muestras y pruebas A/B», aplicado a una tasa:

Margen de una tasa y n mínimo
m=z×√a×(1−a)n
nmin=z2×a×(1−a)m2
donde
a
la tasa medida, como fracción: 0.70 para la aceptación de Alba
n
cuántas publicaciones entraron en la medida (el slice en la ventana)
z
cuántos errores estándar abarca el intervalo, sin unidad: 1.96 para uno de 95 %
m
el margen: la tasa verdadera está en a±m con 95 % de confianza; como fracción (× 100 para puntos)
nmin
cuántas publicaciones hacen falta para que el margen quede en m
El ruido de la aceptación, del total a un sliceLa cuenta
Publicaciones de una semana, n2.5 M al día × 0.99 (sin el holdout) × 7
2,500,000 × 0.99 × 7
≈ 17.3 M
Margen del total, ma = 0.70, z = 1.96
1.96 × √(0.70 × 0.30 ÷ 17,300,000)
± 0.02 puntos
Margen de un slice de 5,000, m0.21 = 0.70 × 0.30
1.96 × √(0.21 ÷ 5,000)
± 1.3 puntos
Margen de un slice de 500, m
1.96 × √(0.21 ÷ 500)
± 4.0 puntos
n mínimo para ± 1.3 puntos, nminm = 0.013; Alba lo redondea a 5,000
1.96² × 0.21 ÷ 0.013²
≈ 4,774
Resultado
Con 17 millones a la semana, 3 puntos es un cambio real sin discusión. Con 5,000 en un slice, el ruido es ± 1.3 puntos (± 1.8 al comparar dos semanas, como explica el recuadro de abajo) y 3 puntos todavía se distinguen. Con 500, el ruido (± 4) es más grande que lo que buscas.

De ahí sale la regla de Alba para los slices (los pedazos del tráfico que se miden por separado: por source, por las ≈ 30 categorías padre y por model_version): un slice solo alerta si tiene al menos 5,000 publicaciones en su ventana. Abajo de eso, se mira en el reporte, pero no se abre ticket.

Para ir más hondoComparar dos semanas tiene más ruido

El disparador compara esta semana contra la anterior, y las dos tienen ruido. El margen de una diferencia de dos tasas independientes con el mismo n es z×√2×a×(1−a)÷n: √2 veces el de una sola. Con 5,000 por semana: 1.96 × √(2 × 0.21 ÷ 5,000) ≈ ± 1.8 puntos. La caída de 3 puntos sigue fuera del ruido, pero con menos holgura de la que parecía. Con 2,500 por semana serían ± 2.5 puntos: casi el umbral.

Para ir más hondoTres slices de una semana, en Python

Tres slices de una semana, con números de ejemplo: los dos source más grandes y una categoría padre chica.

Python
import math

Z, N_MIN, CAIDA = 1.96, 5_000, 0.03   # 95 %, n mínimo y el disparador (3 puntos)
slices = {                     # slice: (n esta semana, a esta semana, a la anterior)
    "source=mobile":      (10_400_000, 0.662, 0.701),
    "source=web":         ( 6_100_000, 0.703, 0.699),
    "padre=Instrumentos": (     3_100, 0.640, 0.690),
}
for nombre, (n, a, a_antes) in slices.items():
    m = Z * math.sqrt(a * (1 - a) / n)          # margen al 95 %
    if n < N_MIN:
        veredicto = "n chico: no alerta"
    elif a_antes - a > CAIDA:
        veredicto = "ticket"
    else:
        veredicto = "estable"
    print(f"{nombre:19} a = {a:.1%} ± {m * 100:.2f} pts  "
          f"cambio {(a - a_antes) * 100:+.1f} pts  {veredicto}")
Salida
source=mobile       a = 66.2% ± 0.03 pts  cambio -3.9 pts  ticket
source=web          a = 70.3% ± 0.04 pts  cambio +0.4 pts  estable
padre=Instrumentos  a = 64.0% ± 1.69 pts  cambio -5.0 pts  n chico: no alerta

mobile es el caso de la app nueva: cayó 3.9 puntos con un ruido de centésimas, y abre ticket. La categoría chica cayó más, 5 puntos, y quizá sea real, pero con 3,100 publicaciones no llega al n mínimo: queda en el reporte, donde alguien la mira con calma. Con ≈ 30 categorías padre y varios source, docenas de slices chicos se moverían cada semana por azar; el n mínimo evita que cada uno abra un ticket.

El ruido de una tasa y el n mínimo de un sliceCalculadora

Cuánto se mueve por azar una tasa medida con n publicaciones. La calculadora aplica m=z×√(a×(1−a)÷n) con z = 1.96 (95 %) y nmin=z2×a×(1−a)÷m2. Arranca con un slice de 5,000 y la aceptación de 70 %.

Margen al 95 % con este n, m (puntos)m=z×√(a×(1−a)÷n)1.27
Margen de la diferencia entre dos semanas (puntos)√2 veces el anterior; el disparador de Alba pide más de 3 puntos1.80
n mínimo para el margen que quieres, nminnmin=z2×a×(1−a)÷m2; Alba pide 5,0004,774

El margen solo cubre el azar de qué publicaciones entraron. Si la tasa está sesgada (la aceptación lo está por la sugerencia), el intervalo sale igual de angosto y no lo avisa.

Arranca con un slice de 5,000 y la aceptación de 70 %. Baja n a 500 y mira cómo el margen pasa los 3 puntos del disparador. Luego mueve el margen que quieres: con ± 1 punto, el n mínimo ya es ≈ 8 mil.

08

Del aviso a la decisión: diagnosticar antes de reentrenar

Esencial

From the alert to the decision: diagnose before retraining

Ya hay un ticket. La tentación es reentrenar: «el modelo empeoró, que aprenda lo nuevo». A veces es lo correcto. Muchas veces no: reentrenar sobre un bug propio le enseña el bug al modelo.

Tres cosas que se descartan primero

Antes de tocar el modelo, quien recibe el ticket descarta, en este orden:

  1. 1

    Un deploy propio

    ¿El cambio empezó justo cuando entró una release, del modelo o del gateway? Si coincide, es nuestro: se hace rollback con el runbook de rollback de «Rollout seguro», no se reentrena.

  2. 2

    Datos rotos del lado de quien llama

    ¿El cambio está en un solo source, o empezó con una versión nueva de la app? Se avisa al dueño de ese cambio. Es el caso de la app nueva.

  3. 3

    Training-serving skew

    ¿Prepara el gateway la foto igual que el entrenamiento? El training-serving skew de «Una foto, vista por un modelo» se ve como drift, pero es un bug: si empeoró desde el día de un deploy, es tu código. Se corre la prueba de paridad de punta a punta: las mismas fotos por el camino del entrenamiento y por el del gateway, y se compara lo que sale.

Solo si cambió el mundo, y los labels lo confirman, se adelanta el reentrenamiento.

De la señal a la acción

Lo que se veLo que se hace
Cambió justo tras un deploy propiorollback; no reentrenar
Un input raro en un solo sourceavisar al dueño; no reentrenar
PSI alto, labels establesetiquetar una muestra; por ahora, nada más
PSI alto y labels peores en el mismo slicetanda extra de ese slice y reentrenar
Labels peores en todos lados, inputs establesconcept drift o cambio de criterio: revisar la guía de etiquetado y reetiquetar
Un cambio anunciado (una categoría nueva)no esperar a la alerta: planearlo
Nada raroel calendario mensual

Los disparadores, y quién aprieta el botón

En Alba, un reentrenamiento se dispara por cuatro caminos:

  • El calendario: la corrida reentreno-mensual, el día 1 de cada mes a las 03:00 UTC, que viste en «Versionado y linaje». Tarda ≈ 4–5 horas y cuesta ≈ US$3–4 de GPU.
  • El PSI > 0.2 tres días seguidos.
  • La aceptación, si cae más de 3 puntos semana contra semana.
  • Una categoría nueva en el árbol, como «bolsas» el 1 de octubre (el árbol pasó de 500 a 501 categorías). Esta es planeada: se sabe antes y no espera a ninguna alerta.

Ninguno de los cuatro reentrena solo. Un disparador abre un ticket, y después del diagnóstico una persona del equipo decide. Si decide adelantar, lanza la corrida a partir del mismo CronWorkflow, la tarea programada de Argo Workflows (el programa que corre los pipelines de Alba dentro de Kubernetes) que lanza reentreno-mensual cada mes:

Terminal
argo submit --from cronwf/reentreno-mensual

Es un comando de ilustración: necesita el clúster de Alba. La corrida adelantada arma un snapshot extra con la fecha del día de corte, por ejemplo ds-2026-11-18 si se lanza el 18 de noviembre, con los labels vigentes ese día. La corrida del día 1 sigue igual.

Y si el ticket lo pide, la persona también encarga una tanda extra de etiquetado: ≈ 500 fotos del slice afectado, elegidas al azar dentro del slice del log, encima de la cola normal de ≈ 5,000. A 5–10 centavos de dólar por foto son ≈ US$25–50, y tardan ≈ 5 días hábiles. Sin labels nuevos del slice que falla, el modelo nuevo no tiene de dónde aprender lo que cambió.

El modelo nuevo sube la misma escalera

Que el disparo sea urgente no salta ningún paso: el mismo gate contra el champion, la paridad del engine, el shadow (despliegue en sombra) de 1–2 días (contesta copias de requests reales sin que nadie vea su respuesta) y el canary de 5 % y 25 % del tráfico, 4 horas cada uno, y luego 100 %, con 24–48 horas de bake time (la versión anterior sigue prendida, para volver a ella con solo cambiar el ruteo). La política en una frase: un reentrenamiento que arranca solo está bien; uno que llega a producción sin gate ni canary, no.

El ciclo se cierra

Con esto la estación 12 entrega lo que la estación 1 necesita: qué fotos etiquetar (la cola del mes, y la tanda extra si hubo ticket) y cuándo armar el snapshot siguiente. Las fotos dudosas que mide la baja confianza son las mismas que la cola elige por incertidumbre. El sistema es un círculo: los datos entrenan un modelo, el modelo atiende, el monitoreo mira cómo atiende, y lo que ve decide qué datos siguen.

Del aviso a la decisión: diagnosticar antes de reentrenar · De la señal a la decisión. Toca cada caja; los tres recorridos siguen el ticket de la app nueva (no se reentrena), un drift real (se adelanta la corrida) y un deploy propio (rollback).
  • señal · PSI · aceptación
    Un disparador: PSI > 0.2 tres días seguidos, o la aceptación cae más de 3 puntos semana contra semana en un slice con ≥ 5,000 publicaciones.
  • ticket · cola de ML
    Un disparador abre un ticket, no un deploy. Nada se reentrena ni se despliega solo.
  • persona del equipo · descarta 3 cosas
    Descarta en orden: (1) un deploy propio, (2) datos rotos de quien llama, (3) training-serving skew. Solo si cambió el mundo y los labels lo confirman, adelanta la corrida.
  • rollback · si fue un deploy
    Si el cambio empezó con una release propia, se vuelve a la anterior con el runbook de rollback. Reentrenar le enseñaría el bug al modelo.
  • aviso al dueño · si fue quien llama
    Si el cambio vive en un solo source (la app nueva), se avisa al equipo dueño de ese cambio. El modelo no tiene la culpa.
  • tanda extra · ≈ 500 fotos
    ≈ 500 fotos del slice afectado, al azar dentro del slice, encima de la cola de ≈ 5,000: ≈ US$25–50 y ≈ 5 días hábiles.
  • corrida adelantada · argo submit
    Una persona la lanza desde el CronWorkflow reentreno-mensual. Tarda ≈ 4–5 h y cuesta ≈ US$3–4 de GPU. La del día 1 sigue igual.
  • snapshot · ds-2026-11-18
    El snapshot extra lleva la fecha del día de corte y los labels vigentes ese día (aquí, si se lanzara el 18 de noviembre).
  • cola del mes · estación 1
    El ciclo vuelve a empezar: la cola de ≈ 5,000 fotos de cada mes, con las dudosas que eligió la baja confianza.
  • la misma escalera · gate → canary
    El candidato pasa el gate, la paridad, el shadow de 1–2 días, el canary de 5 % y 25 % y el bake. Urgente no quiere decir sin pasos.
09

Vigilar al que vigila: el job diario y su frescura

Extra

Watching the watcher: the daily job and its freshness

El PSI del día, la aceptación por slice y los bytes por source no salen de ningún pod con métricas: los calcula un job que corre y termina. En Alba es el CronWorkflow monitoreo-diario de Argo Workflows, a las 01:00 UTC, sobre el día UTC anterior. Tarda ≈ 20 minutos y hace cinco cosas:

  1. Pasa el log crudo de S3 a Parquet, partido por dt y model_version.
  2. Calcula el PSI de las ≈ 30 categorías padre contra las 4 semanas previas.
  3. Calcula la aceptación por día y por slice (une el log con los eventos del backend por request_id).
  4. Cuenta bytes y tasas de 4xx por source.
  5. Publica cada resultado como gauge (una métrica que sube y baja) en el Pushgateway.

Por qué un Pushgateway

Prometheus lee métricas de quien está vivo: cada 15 segundos hace un scrape, va y pregunta. Un job de 20 minutos tiene sus resultados hasta el final, justo antes de terminar a las 01:20: ningún scrape los alcanza con seguridad, y después ya no hay a quién preguntar. El Pushgateway es un programa que se queda prendido: el job le empuja sus resultados al terminar, y Prometheus los lee de ahí como de cualquier pod.

La trampa: el Pushgateway nunca olvida

El Pushgateway guarda el último valor de cada serie hasta que alguien lo borre: no tiene caducidad. (Solo lo pierde si se reinicia sin guardar a disco.) Si el job deja de correr (un cambio de permisos en S3, una imagen que ya no existe), el último PSI se queda publicado para siempre: 0.002, estable, día tras día. El dashboard se ve perfecto, y nada se está midiendo.

La defensa es medir la frescura del job: cuánto hace que publicó por última vez. El Pushgateway guarda, para cada grupo de métricas, la serie push_time_seconds: la hora del último envío, en segundos desde 1970. La alerta MonitoringJobStale abre un ticket si time() - push_time_seconds pasa de 26 horas. ¿Por qué 26 y no 24? El job corre cada 24 horas y tarda ≈ 20 minutos; con 2 horas de margen, un día en que tarde un poco más no abre un ticket, y uno en que no corre sí.

Es la misma idea de LogsStale: si no llega un archivo nuevo de log a S3 en 30 minutos, algo se rompió en el camino aunque nadie se queje. Un monitor que puede morir en silencio necesita su propio monitor.

10

La guardia: dashboards, runbooks, fatiga y postmortems

Extra

On-call: dashboards, runbooks, fatigue and postmortems

Un dashboard por audiencia

Un dashboard es una página de gráficas en vivo; Alba los arma en Grafana, que consulta a Prometheus. Tiene cuatro, porque cada audiencia hace otra pregunta:

DashboardPara quiénQué tiene
Serviciola guardiaarriba, el SLO y el presupuesto que queda; abajo, tasa, errores y latencia por tramo, con marcas de cada deploy
Triton y GPUla guardia y el equipofila contra cómputo, batch promedio, réplicas contra el tope de KEDA
Modeloel equipo de MLscore top-1, baja confianza, las 20 categorías más grandes contra su línea base; todo por model_version
Negocioproductodiario: aceptación, recategorización, publicaciones completadas

Un dashboard que sirve a los tres no le sirve a ninguno: la guardia a las 3 de la mañana necesita ver en 10 segundos si el SLO está en peligro, no buscarlo entre 40 gráficas de categorías.

El runbook del p99

Un runbook es la receta de qué hacer cuando suena una alerta, escrita en calma para usarse con prisa. El de ClassifierHighP99Latency, en el orden en que Marta lo sigue:

  1. 1

    ¿Qué tramo subió?

    El preproceso, la fila de Triton o el cómputo. El dashboard de servicio los muestra por separado.

  2. 2

    ¿Hubo deploy?

    Si el salto coincide con una release, rollback con el runbook de «Rollout seguro».

  3. 3

    ¿KEDA está en su tope de 4 réplicas?

    Si la fila crece y ya no hay más réplicas, falta GPU: se sube el tope o se agrega capacidad.

  4. 4

    ¿Un cliente manda de más?

    Si un solo cliente duplicó su tráfico, se aplica su cuota.

  5. 5

    Escalar

    Si en 30 minutos no mejora, Marta llama a otra persona del equipo.

La regla de fondo: mitigar primero, entender después. A las 3 de la mañana, volver a la versión anterior y entender mañana es mejor que entender ahora con el SLO ardiendo.

Fatiga de alertas

Si una alerta suena seguido y nunca pasa nada, la gente deja de mirarla, y la vez que importa también la ignora. Eso es la fatiga de alertas. Se mide así: qué fracción de los pages terminó en una acción. Con números de ejemplo: si en un mes hubo 12 pages y en 9 alguien hizo algo, 75 %; los 3 restantes son candidatos a borrar o a bajar a warning. Una alerta que nadie atendió en un mes no protege nada: estorba.

Postmortem sin culpables

Después de todo page con impacto en los usuarios, Alba escribe un postmortem sin culpables en ≤ 5 días hábiles. Es sin culpables (blameless): no busca quién se equivocó, sino qué dejó que el error llegara a producción. Lleva línea de tiempo, impacto, con qué señal se detectó y acciones con dueño y fecha.

En ML la pregunta clave es otra: ¿qué señal lo habría detectado antes? Si a la app nueva la descubrió la aceptación 6 días después, la acción puede ser una alerta de datos: un aviso si la mediana de bytes de un source cae más de un cuarto en un día. Si lo encontró un usuario, falta una métrica. Si lo encontró una alerta tres semanas tarde, falta una señal más rápida.

11

Errores comunes

Esencial

Common mistakes

12

En la vida real

Extra

In real life

Alba. Todo lo de esta lección corre todos los días: 12 alertas con su severidad, un job diario que publica el PSI y la aceptación por slice, una guardia de 5 personas y una política que no deja que nada se despliegue solo.

Inspección industrial. Un modelo que rechaza piezas defectuosas solo recibe labels de las que rechazó, porque esas las revisa una persona. Se ve cuántos rechazos eran falsos (la precisión), pero no cuántas piezas malas pasaron (el recall). La defensa es la idea del holdout: piezas patrón con defectos conocidos y una muestra de aprobadas que se revisa a mano.

Un sistema con cola de mensajes. Si un sistema procesa trabajos de una cola, su saturación no es cuántos mensajes hay, sino la edad del más viejo: mil mensajes que salen en un segundo no preocupan; uno que lleva una hora, sí. Y los mensajes que siempre fallan terminan en la DLQ, que tiene su propia alerta.

Fraude y recomendación. En fraude, solo se sabe que una transacción lo era cuando alguien reclama, semanas después, y solo de las que el modelo dejó pasar. En recomendación, solo se sabe si gustó lo que se mostró. En los dos, como en la aceptación de Alba, el label está filtrado por el modelo, y hace falta una muestra chica al azar que no lo esté.

Un LLM o el asistente con RAG. Un LLM genera texto token por token (pedazos de palabra); con RAG (retrieval-augmented generation), antes de contestar busca y lee los documentos que sirven. El asistente interno de Alba responde así ≈ 25 mil preguntas al día con los documentos de la empresa. Su latencia se vigila por token (el tiempo hasta el primer token y entre tokens), y su calidad, con muestras de respuestas que califica una persona u otro modelo: ahí no hay «aceptación» automática.

13

Ejercicios

Esencial

Exercises

Resuélvelos con lápiz antes de abrir la solución. Usa las letras de la lección: S, p, β, t, V, f, ta, R, B, F (burn rate); c, c7, Nbaja, Ntotal (baja confianza); a, n, z, m, nmin (el ruido de una tasa); W, Dq, Nok (la fila de Triton).

  1. 1Fácil

    Un deploy malo hace fallar 2 % de las requests de Alba. ¿Cuál es su burn rate? ¿Suena el page si dura una hora? ¿En cuántas horas se acabaría el presupuesto del mes?

    Ver la solución paso a paso
    • β=p÷(1−S) = 0.02 ÷ 0.001 = 20×.
    • La ventana de 5 minutos pasa 14.4× casi enseguida. La de 1 hora promedia 20× por la fracción de la hora que lleva el deploy, así que llega a 14.4× cuando esa fracción es 14.4 ÷ 20: a los 14.4 ÷ 20 × 60 ≈ 43 minutos. Si dura una hora, sí suena.
    • ta=V÷β = 720 ÷ 20 = 36 horas.
  2. 2Fácil

    Clasifica cada alerta en page, warning o ticket, como Alba: (a) la fila de Triton en 25 ms durante 15 minutos; (b) la baja confianza en 9 % durante una hora; (c) el ALB contesta 503 a todo; (d) el PSI en 0.23 un solo día.

    Ver la solución paso a paso
    • (a) Warning (TritonQueueTimeHigh): anticipa un page, pero el usuario todavía no está afectado.
    • (b) Ticket (ClassifierLowConfidenceSpike): es calidad del modelo; si la base es ≈ 4 %, 9 % pasa el doble.
    • (c) Page (ALB5xx): todos los usuarios están afectados ahora.
    • (d) Nada todavía: la regla pide más de 0.2 tres días seguidos.
  3. 3Fácil

    En un minuto del pico, el contador de la fila de Triton crece Dq = 1,470,000,000 µs y el de éxitos Nok = 21,000. ¿Cuánto es W? ¿Suena algo si dura así 10 minutos?

    Ver la solución paso a paso
    • W=Dq÷Nok÷1,000 = 1,470,000,000 ÷ 21,000 ÷ 1,000 = 70,000 ÷ 1,000 = 70 ms.
    • Pasa los 20 ms: tras 10 minutos, warning TritonQueueTimeHigh. Con 70 ms de fila, la request típica de 20 ms ya va en ≈ 90, y el p99 se acerca a los 200: es probable que pronto también suene el page del p99.
  4. 4Fácil

    La aceptación de un slice es 70 % con n = 2,000 publicaciones. ¿Cuánto es su margen? ¿Puede alertar en Alba?

    Ver la solución paso a paso
    • m=z×√(a×(1−a)÷n) = 1.96 × √(0.21 ÷ 2,000) = 1.96 × 0.0102 ≈ ± 2.0 puntos.
    • No alerta: tiene menos de 5,000. Se ve en el reporte.
  5. 5Medio

    El PSI del día sale 0.25 el martes, el miércoles y el jueves. Ese martes entró la release del gateway que cambió cómo se decodifica WebP. La aceptación no se movió. ¿Qué se hace?

    Ver la solución paso a paso
    • Se abre el ticket (tres días seguidos arriba de 0.2), pero el diagnóstico va primero.
    • Deploy propio: el cambio empezó el día de la release. Es lo primero que se descarta, y aquí coincide. Se compara el PSI por formato de foto; si el salto está en las WebP, es el código.
    • Acción: rollback del gateway o un arreglo, y una prueba de paridad que incluya WebP. No se reentrena: el modelo aprendería a convivir con una decodificación rota.
Para ir más hondoCinco ejercicios más, para la segunda pasada
  1. 1Medio

    Durante 6 horas, Alba falla 0.8 % de las requests y en la última media hora sigue igual. ¿Qué alerta suena? ¿Cuántas requests fallaron y qué parte del presupuesto se fue?

    Ver la solución paso a paso
    • β=p÷(1−S) = 0.008 ÷ 0.001 = 8×: pasa 6× en 6 h y en 30 min, pero no 14.4×. Suena el ticket ClassifierErrorBudgetSlowBurn, no el page.
    • F=R÷24×t×p = 416,667 × 6 × 0.008 ≈ 20,000 requests.
    • f=β×t÷V = 8 × 6 ÷ 720 ≈ 6.7 % del mes (= 20,000 ÷ 300,000).
  2. 2Medio

    A las 4 de la mañana llegan 25 requests por segundo. En media hora, ¿cuántas fotos dudosas dispararían ClassifierLowConfidenceSpike si c7 = 4 %? ¿Y si el tráfico fuera de 0.5 requests por segundo?

    Ver la solución paso a paso
    • Ntotal = requests por segundo × 1,800 s = 25 × 1,800 = 45,000. El ticket pide Nbaja>2×c7×Ntotal = 0.08 × 45,000 = 3,600 fotos dudosas, sostenido 30 minutos.
    • Con 0.5 por segundo no llega al volumen mínimo (más de 1 por segundo): no dispara, por más alta que sea la tasa. Con 900 requests en la media hora, 18 fotos dudosas de más moverían la tasa 2 puntos.
  3. 3Medio

    Una persona propone cambiar MonitoringJobStale de 26 a 48 horas «para que haga menos ruido». ¿Qué se pierde? Supón que el job deja de correr el lunes a las 01:00 UTC, justo después de su última corrida buena del domingo.

    Ver la solución paso a paso
    • Con 26 h: la última publicación fue el domingo ≈ 01:20; el ticket se abre el lunes ≈ 03:20, ≈ 2 horas después de la corrida que faltó.
    • Con 48 h: se abre el martes ≈ 01:20. Un día entero más con el PSI y la aceptación congelados en el valor del domingo.
    • Si en esos días empieza un drift real, la regla de «3 días seguidos» tarda un día más en contar. El ruido que se ahorra es casi cero: el job corre una vez al día.
  4. 4Reto

    Diseña la señal que habría detectado la app nueva antes que la aceptación. Tienes el histograma classifier_image_bytes (los bytes de cada foto) por source. La mediana de mobile bajó de ≈ 210 KB a ≈ 140 KB. Propón una regla con su severidad, su ventana y su defensa contra falsas alarmas, y di por qué no debe ser un page.

    Ver la solución paso a paso
    • Una regla que compara la mediana (el p50 estimado desde los buckets) de bytes de cada source contra su promedio de 7 días: aviso si cae más de 25 % durante 2 horas. 140 ÷ 210 ≈ 0.67: una caída de ≈ 33 %, que la pasa.
    • Defensas: volumen mínimo por source (que internal, con poco tráfico, no dispare solo), for de 2 horas y comparar cada source contra sí mismo, no contra el total.
    • Severidad: ticket. Una foto más chica no prueba que el modelo falle; abre una investigación (¿hubo una versión nueva de la app?) y le gana 6 días a la aceptación. No es page porque el usuario no está afectado de forma medible ahora y la guardia no puede arreglar la app de madrugada.
  5. 5Reto

    Alba quiere un tercer nivel de burn rate, como el del libro de SRE: perder 10 % del presupuesto en 3 días. ¿Qué β le toca, qué ventana corta y qué fracción de errores? ¿Qué severidad le pondrías?

    Ver la solución paso a paso
    • β=f×V÷t = 0.10 × 720 ÷ 72 = 1×: gastar el presupuesto justo al ritmo que lo acaba en el mes.
    • Ventana corta: 1/12 de 72 h = 6 horas.
    • p=β×(1−S) = 0.1 %: el ritmo normal permitido, sostenido 3 días.
    • Severidad: ticket. A ese ritmo el mes alcanza justo; no hay emergencia, pero conviene saberlo antes de gastar el resto en deploys.
14

Lo que sigue

Esencial

What comes next

Esta es la última estación, y no termina: devuelve el sistema a donde empezó.

  • «Datos y etiquetas» recibe la cola del mes, las tandas extra y las fotos dudosas; relee «El feedback loop y el holdout» con lo que ahora sabes de la aceptación.
  • «Versionado y linaje» arma el snapshot siguiente, del calendario o de una corrida adelantada, y el pipeline mensual lo entrena («El pipeline mensual como DAG»).
  • Y el modelo nuevo vuelve a subir «Gate de evaluación y registry» y «Rollout seguro».

Para repasar las bases: «Probabilidad para sistemas que fallan» (el presupuesto de error), «Ruido, muestras y pruebas A/B» (el intervalo), «Comparar distribuciones: cómo se mide el drift» (el PSI y la trampa del n enorme), «Promedios, medianas y percentiles» (el p99) y «La request en vivo» (las métricas).

15

Palabras que vas a oír

Esencial

Words you will hear

Los conceptos que presentó esta lección, cada uno con su tarjeta:

Falla silenciosasilent failureCuando un modelo empeora sin que nada truene: el servicio sigue contestando 200 OK (el código de «todo bien»), igual de rápido y con la misma seguridad aparente, pero sus respuestas son peores.Más

Un servidor web roto se nota porque deja de contestar. Un modelo roto sigue contestando. Casi nunca cambió el modelo: cambió el mundo que lo alimenta (las fotos, la gente, lo que se vende), y eso es drift. Por eso no bastan las señales de servicio: hacen falta señales del modelo y del negocio, en las cinco capas del monitoreo.

Analogía. Como un termómetro que se descalibra: sigue marcando un número cada vez que lo miras, solo que ya no es la temperatura. Se rompe en que el termómetro sí cambió; en un modelo, casi siempre cambió lo que mide.

Ejemplo. Una versión nueva de la app manda las fotos más comprimidas. El p99 de un pod del gateway sigue en ≈ 69 ms o menos (el de su pico de diseño) y no hay errores de más; seis días después, la aceptación de source=mobile cae de 70.1 % a 66.2 %.

Ver en el glosario →

Las cinco capas del monitoreomonitoring layersInfraestructura, servicio, datos, modelo y negocio: lo que se vigila de un sistema de ML, de la señal más rápida (segundos) a la más lenta y más cercana a lo que importa (semanas).Más

Las dos primeras capas existen en cualquier servicio (nodos, pods, latencia, errores). Las tres siguientes son propias de ML: los datos que entran (tamaño, formatos), lo que contesta el modelo (score, baja confianza, PSI) y lo que pasa después (aceptación, correcciones, labels: las respuestas correctas). La regla incómoda: cuanto más abajo, más lenta la señal, porque el label que dice si se acertó llega tarde.

Ejemplo. En Alba: infraestructura (pods listos, segundos) · servicio (p99, 5xx, fila de Triton) · datos (bytes por source, minutos) · modelo (baja confianza, PSI, hasta 1 día) · negocio (aceptación, holdout, horas a semanas).

Ver en el glosario →

Señales doradasgolden signalsCuatro preguntas para vigilar cualquier servicio: cuánto tarda (latencia), cuánto le piden (tráfico), cuánto falla (errores) y qué tan lleno está (saturación).Más

Vienen del libro de SRE (Site Reliability Engineering) de Google. Dos recetas hermanas dicen lo mismo desde otro ángulo: RED (rate, errors, duration: tasa, errores, duración) para cada servicio, y USE (utilization, saturation, errors: utilización, saturación, errores) para cada recurso, como una GPU o un disco. La saturación se mide mejor con la fila (cuánto se espera) que con la utilización: una GPU al 100 % puede no tener a nadie esperando.

Ejemplo. En Alba: latencia = el p99 contra 200 ms; tráfico ≈ 116 requests por segundo en promedio; errores = 5xx ÷ requests sin 4xx; saturación = la espera media en la fila de Triton, con warning arriba de 20 ms durante 10 minutos.

Ver en el glosario →

Señal sin labels (proxy de calidad)proxy metricUna señal que se mide sin saber la respuesta correcta y avisa «algo cambió» en minutos: la mezcla de categorías predichas, el score top-1 (la probabilidad de la primera opción del modelo), la tasa de baja confianza o el tamaño de las fotos.Más

Los labels llegan tarde, así que mientras tanto se vigila lo que sí se sabe en el momento: qué contestó el modelo y cómo venía la entrada. Ningún proxy prueba que el modelo empeoró: un cambio en la mezcla puede ser la temporada. Sirven para sospechar, abrir un ticket, mirar muestras y mandar a etiquetar; los labels demorados confirman.

Ejemplo. La tasa de baja confianza de Alba sube de 4 % a 5.5 % el día que sale una versión nueva de la app: no prueba nada, pero apunta a dónde mirar.

Ver en el glosario →

Tasa de baja confianzalow-confidence rateLa fracción de las predicciones cuya probabilidad más alta (el score top-1) queda debajo de un umbral. En Alba, la de las fotos con top-1 menor que 0.3: ≈ 4 % en un día normal.Más

Se calcula con dos contadores del histograma del score: el bucket del umbral entre el total, en una ventana de 30 minutos, con una regla de grabación. Se compara contra su propio promedio de 7 días, porque la tasa normal se mueve con las temporadas. Ve las dudas del modelo, no sus errores seguros: un modelo mal calibrado puede equivocarse con 0.9.

Ejemplo. En media hora de tráfico promedio de Alba hay 208,800 requests y ≈ 8,352 fotos dudosas (4 %). El ticket ClassifierLowConfidenceSpike pide más del doble de su promedio de 7 días (≈ 8 %) durante 30 minutos, con más de 1 request por segundo.

Ver en el glosario →

Tasa de aceptaciónacceptance rateDe las publicaciones donde la pantalla mostró las sugerencias, la fracción cuya categoría se eligió entre ellas. En Alba, ≈ 70 %.Más

Es la señal de negocio más rápida: llega en minutos u horas. Se mide con los eventos de quien llama (en Alba, suggestion_shown y category_selected del backend), no con el log del servidor, que no sabe si la sugerencia se llegó a pintar. Está sesgada: la gente tiende a aceptar lo que le mostraron (bucle de retroalimentación), así que no sirve para medir la exactitud real; para eso está el holdout.

Ejemplo. Con ≈ 17.3 M publicaciones a la semana, el azar mueve la aceptación de Alba ± 0.02 puntos; el disparador pide una caída de más de 3 puntos semana contra semana.

Ver en el glosario →

Referencia y ventana del driftreference windowContra qué se compara la distribución de hoy para decir si hubo drift, y sobre cuánto tiempo. Cada referencia ve una cosa y se pierde otra.Más

Contra los datos de entrenamiento, la pregunta es «¿ve algo que no aprendió?», pero si el mundo se movió para siempre, la alerta suena sin parar. Contra una ventana reciente, la pregunta es «¿cambió de golpe?», pero un cambio lento nunca se ve, porque cada semana se parece a la anterior. Por eso se usan dos. Además se pide que el cambio se sostenga, para que un día raro no dispare nada.

Ejemplo. Alba compara el PSI diario contra las 4 semanas previas (la alerta, si pasa de 0.2 tres días seguidos) y contra el mes del snapshot del champion, ds-2026-09-01 para la release 14 (el reporte mensual).

Ver en el glosario →

Regla de alertaalerting ruleUna condición que el sistema de monitoreo evalúa cada cierto tiempo y que, si se cumple el tiempo suficiente, avisa a alguien. Lleva nombre, condición, cuánto tiene que durar (for), severidad, dueño y runbook (la receta de qué hacer).Más

Se alerta por síntomas (lo que siente el usuario), no por causas. El for pide que la condición dure antes de disparar, para que un pico de un deploy no despierte a nadie. Hay que protegerla del tráfico bajo (un error en 20 requests es 5 %) y de las series ausentes: si el servicio muere, sus métricas desaparecen y la regla no da nada, así que se alerta también con up == 0, absent() o desde quien espera la señal. Si no hay acción posible, no es un page (una alerta que despierta a alguien).

Ejemplo. ClassifierHighP99Latency de Alba: p99 > 200 ms durante 10 minutos, severidad page, para la guardia, con el runbook del p99 enlazado.

Ver en el glosario →

Severidad de una alertaalert severityQué tan urgente es una alerta y a quién le llega: page (despierta a la guardia), warning (canal del equipo, en horario) o ticket (trabajo de la semana).Más

Page solo para lo que afecta a los usuarios ahora y alguien puede arreglar ahora. Warning para una causa que anticipa un page. Ticket para la calidad del modelo y las tendencias, que se entienden mirando datos con calma. Poner todo en page lleva a la fatiga de alertas.

Ejemplo. En Alba, el p99 arriba de 200 ms es page; la fila de Triton arriba de 20 ms, warning; el PSI arriba de 0.2 tres días seguidos, ticket. Nadie se despierta a las 3 de la mañana porque subió el PSI.

Ver en el glosario →

AlertmanagerAlertmanagerEl programa que recibe las alertas que dispara Prometheus y decide a quién y cómo avisar: agrupa, deduplica, inhibe y silencia.Más

Prometheus solo decide que una alerta suena. Alertmanager agrupa las de un mismo incidente en una notificación, deduplica las que llegan repetidas de dos Prometheus iguales, inhibe las que son consecuencia de otra y silencia durante un mantenimiento. También enruta cada severidad a su canal (el teléfono de la guardia, el chat del equipo, la cola de tickets).

Ejemplo. En Alba vive en el namespace monitoring, agrupa por alerta y namespace y calla los warning de la fila de Triton mientras TritonNotReady está sonando.

Ver en el glosario →

Regla de grabaciónrecording ruleUna expresión cara que el sistema de métricas calcula cada cierto tiempo y guarda como una serie nueva, para que las alertas y los dashboards la lean ya hecha.Más

Calcular una tasa de 6 horas o promediar 7 días suma millones de muestras; si cada alerta la recalcula en cada evaluación, el sistema trabaja de más. La regla de grabación la calcula cada cierto tiempo (en Alba, una vez por minuto) y le da un nombre propio, por costumbre de tres partes: nivel, métrica y operación (classifier:error_ratio:rate1h).

Ejemplo. Alba graba la fracción de errores en 5 min, 30 min, 1 h y 6 h para sus alertas de burn rate, y classifier:low_confidence_share:rate30m para comparar la baja confianza contra su promedio de 7 días.

Ver en el glosario →

Burn rateburn rateQué tan rápido se gasta el presupuesto de error (lo que el SLO, la meta del servicio, deja fallar), comparado con el ritmo que lo agotaría justo al final de la ventana del SLO. 1× lo gasta exacto en el mes; 14.4×, en 50 horas.Más

Se calcula como β=p÷(1−S): la fracción de errores de una ventana entre la fracción que permite el SLO. En una ventana de t horas se gasta β×t÷V del presupuesto, con V = 720 h. Alertar con el burn rate en vez de un umbral fijo mide el daño: un pico corto gasta poco aunque sea alto, y un goteo de toda la semana gasta mucho aunque sea bajo.

Ejemplo. Con el SLO de 99.9 % de Alba, un 1.44 % de errores es 14.4×: en una hora se van ≈ 6,000 requests, 2 % de las 300,000 del mes. Un deploy malo con 5 % de errores es 50×: el mes duraría 14.4 horas.

Ver en el glosario →

Alerta multiventanamultiwindow, multi-burn-rate alertUna alerta de burn rate que mira dos ventanas a la vez, una larga y una corta (1/12 de la larga), y suena solo si las dos pasan el umbral.Más

La ventana larga confirma que el problema es real: un pico de dos minutos no mueve el promedio de una hora. Pero tiene memoria y seguiría arriba mucho después del arreglo. La corta casi no tiene memoria: cuando el incidente termina, baja en minutos y la alerta se apaga. Se combinan varios niveles (rápido y lento) para cubrir incidentes graves y goteos.

Ejemplo. Alba: page a 14.4× en 1 h y en 5 min; ticket a 6× en 6 h y en 30 min. Un incidente al 3 % durante 40 min, con 0.1 % de fondo (el tope que deja el SLO; supuesto del ejemplo), hace sonar el page del minuto 27 al 42; con la ventana larga sola, sonaría hasta el 72.

Ver en el glosario →

DashboarddashboardUna página de gráficas en vivo que muestra las métricas de un sistema. En Alba se arman en Grafana, un programa de gráficas que consulta a Prometheus.Más

Un dashboard sirve si contesta rápido la pregunta de quien lo mira, así que se hace uno por audiencia: la guardia necesita ver en segundos si el SLO está en peligro; el equipo de ML, cómo se comporta el modelo por versión; producto, el negocio día a día. Uno que sirve a los tres no le sirve a ninguno. Un dashboard no avisa: para eso están las alertas.

Ejemplo. Los cuatro de Alba: servicio (el SLO y el presupuesto arriba, con marcas de deploy), Triton y GPU, modelo (todo por model_version) y negocio (diario).

Ver en el glosario →

Guardiaon-callLa persona del equipo que, por turno, recibe las alertas urgentes (los page) y responde a cualquier hora.Más

La guardia rota entre las personas del equipo para que nadie la cargue siempre. Recibe solo lo que no puede esperar; lo demás llega como warning o ticket en horario. Sigue los runbooks y, si el incidente afectó a los usuarios, al final se escribe un postmortem sin culpables.

Ejemplo. En Alba es una rotación semanal entre las 5 personas del equipo; en los ejemplos, Marta. Reconoce cada page en ≤ 5 minutos.

Ver en el glosario →

RunbookrunbookLa receta escrita de qué revisar y qué hacer cuando suena una alerta, enlazada desde la alerta misma. Se escribe en calma para usarse con prisa.Más

Un buen runbook va en orden de lo más probable y lo más rápido de mitigar, y dice cuándo escalar. La regla de fondo: mitigar primero, entender después. El runbook de rollback es un caso particular.

Ejemplo. El runbook del p99 de Alba: (1) qué tramo subió, (2) ¿hubo deploy? → rollback, (3) ¿KEDA en su tope de 4? → falta GPU, (4) ¿un cliente manda de más? → su cuota, (5) escalar si en 30 minutos no mejora.

Ver en el glosario →

Fatiga de alertasalert fatigueCuando suenan tantas alertas que no llevan a nada que la gente deja de hacerles caso, y la que importa también se ignora.Más

Nace de alertas sin for, sin volumen mínimo, por causas en vez de síntomas, o de pages que deberían ser tickets; y de muchas pruebas a la vez (comparaciones múltiples). Se mide con la fracción de pages que terminaron en una acción, y se cura borrando o bajando de severidad lo que nadie atendió.

Ejemplo. Con números de ejemplo: 12 pages en un mes y solo 9 con acción es 75 %; los otros 3 son candidatos a borrar o a pasar a warning.

Ver en el glosario →

Postmortem sin culpablesblameless postmortemEl documento que se escribe después de un incidente: qué pasó, cuánto afectó, cómo se detectó y qué se hará para que no se repita, sin buscar a quién culpar.Más

Lleva línea de tiempo, impacto, con qué señal se detectó y acciones con dueño y fecha. Es sin culpables porque busca qué dejó pasar el error, no quién lo cometió: así la gente cuenta lo que de verdad pasó. En ML la pregunta clave es qué señal lo habría detectado antes.

Ejemplo. Alba escribe uno después de cada page con impacto en usuarios, en ≤ 5 días hábiles. Si una versión nueva de la app que comprimía más las fotos solo se detectó seis días después, por la caída de la aceptación, una acción puede ser una alerta por bytes de cada source.

Ver en el glosario →

Frescura de un job (y Pushgateway)job freshness · PushgatewayCuánto tiempo hace que un job (un programa que corre y termina) publicó su último resultado. Se vigila porque un job muerto deja su último valor publicado y todo parece estable.Más

Prometheus lee métricas de quien está vivo; un job que corre y termina las empuja al Pushgateway, un programa que se queda prendido y que las guarda hasta que alguien las borre, junto con push_time_seconds, la hora del último envío. Si el job deja de correr, el último valor se queda para siempre. La defensa es una alerta sobre time() - push_time_seconds.

Ejemplo. El job monitoreo-diario de Alba corre a las 01:00 UTC y tarda ≈ 20 minutos; MonitoringJobStale abre un ticket si pasan más de 26 horas sin un envío nuevo.

Ver en el glosario →

Disparador de reentrenamientoretraining triggerUna condición que propone reentrenar el modelo antes del calendario. Abre un ticket para que una persona diagnostique y decida; no despliega nada solo.Más

Antes de adelantar se descarta lo que no es del mundo: un deploy propio, datos rotos de quien llama y el training-serving skew. Solo si cambió el mundo y los labels lo confirman, se adelanta la corrida, con una tanda extra de etiquetado del slice si hace falta, y el modelo nuevo sube los mismos peldaños: gate, shadow (despliegue en sombra) y canary.

Ejemplo. En Alba: el calendario (día 1, 03:00 UTC), el PSI > 0.2 tres días seguidos, la aceptación −3 puntos semana contra semana y una categoría nueva planeada. Una persona lanza argo submit --from cronwf/reentreno-mensual.

Ver en el glosario →

Brecha offline–onlineoffline–online gapLa diferencia entre lo bien que le va a un modelo en el examen fijo (offline) y lo bien que le va con el tráfico real (online).Más

El examen fijo, como un golden set, no cambia; el mundo sí. Si la medida online cae y la offline no, el mundo ya no se parece al examen: hace falta actualizar el examen o reentrenar. La medida online tiene que estar libre del sesgo de la sugerencia, como el holdout.

Ejemplo. En Alba, el golden set da ≈ 85 % de top-1 y el holdout ≈ 85 % ± 0.1 punto: la brecha hoy es casi cero. Si un mes el holdout cae a 82 %, se abre la investigación.

Ver en el glosario →

16

Chequeo

Esencial

Check

Intenta responder en tu cabeza antes de abrir cada respuesta.

  1. 1¿Por qué un modelo puede fallar sin que el dashboard del servicio lo note?Ver respuesta

    Porque sigue contestando 200 OK con la misma latencia y la misma confianza aparente. Cambió el mundo que lo alimenta, no el servicio.

  2. 2¿Qué decide si una alerta es page, warning o ticket?Ver respuesta

    Si el usuario está afectado ahora y alguien puede arreglarlo ahora (page), si es una causa que anticipa un page (warning) o si es calidad del modelo y tendencias (ticket).

  3. 3¿Qué es un burn rate de 14.4× y por qué Alba lo usa en vez de «más de 1 % de errores»?Ver respuesta

    Gastar el presupuesto 14.4 veces más rápido de lo que lo agota en 30 días: 2 % del mes en una hora. Mide el daño contra el presupuesto; un umbral fijo no sabe cuánto daño hace un error.

  4. 4¿Para qué sirve la ventana corta de una alerta multiventana?Ver respuesta

    Para que la alerta se apague pronto cuando el incidente se arregla. La larga confirma que es real; la corta tiene poca memoria.

  5. 5¿Por qué la aceptación no basta para medir la exactitud real?Ver respuesta

    Porque quien vende tiende a aceptar lo que le mostraron: está sesgada por el modelo. La medida limpia es el holdout, que no ve sugerencias.

  6. 6¿Qué hace en Alba un disparador de reentrenamiento?Ver respuesta

    Abre un ticket. Después del diagnóstico, una persona decide si adelanta la corrida; el modelo nuevo sube igual el gate, el shadow y el canary.

Repasar los 21 conceptos de esta lección con tarjetas Terminaste el curso¿Qué sigue después de Sensei?Practicar con código y defender el diseño en una entrevista. Practícalo con códigoEstación 12 del Dojo: Monitoreo y reentrenamientoEl Dojo es la parte de TrueML donde construyes, rehaces y rompes cada pieza del sistema de Alba con Claude Code. ← 57 · La request en vivo