Cabeza
head
La parte final de una red, chica, que convierte lo que entrega el backbone en la respuesta de la tarea: un logit por categoría, cajas o una máscara.
Es lo que se cambia al reutilizar un backbone para otra tarea (transfer learning). En clasificación es un pooling más una capa densa; en detección, una capa que propone una caja y un puntaje por clase en cada posición; en segmentación, un decoder que agranda los mapas hasta dar una respuesta por píxel. No confundir con las «cabezas de atención» de un transformer, que son otra cosa.
Ejemplo. La cabeza de la ResNet-50 de Alba, que elige entre 500 categorías, es una capa densa de 2,048 → 500: entradas × salidas + salidas = 2,048 × 500 + 500 = 1,024,500 parámetros. La original de ImageNet, de 1,000 categorías, tiene 2,049,000.
Caché
cache · hit · miss · hit rate
Una copia de un resultado guardada en un lugar rápido y cercano, para no repetir el trabajo de calcularlo o traerlo. Si la copia está, es un acierto (hit); si no, un fallo (miss).
La tasa de aciertos (hit rate) dice qué fracción de pedidos encontró la copia, y con ella se calcula la latencia promedio: aciertos × lo que tarda un acierto + fallos × (revisar el caché + el trabajo completo): T=h×a+(1−h)×(a+w), con h la tasa de aciertos, a lo que tarda un acierto y w el trabajo completo. La forma más común es cache-aside: buscar en el caché, y si no está, hacer el trabajo y guardar la copia con un TTL. Las copias envejecen: se invalidan borrando la llave al escribir, y el TTL es la red de seguridad. La llave debe incluir todo lo que cambia la respuesta (en Alba, el hash de la foto más la versión del modelo). Cuando se llena, sale lo que lleva más sin usarse (LRU). Es la misma idea de la caché de la CPU, la page cache y el TTL del DNS, en otro piso. Lo que importa al final no es la tasa, sino cuánta capacidad te deja quitar.
Ejemplo. Con 20 % de aciertos, un acierto de 1 ms y un paso del modelo de ≈ 30 ms (los 27 ms de las requests lentas, redondeados), la latencia promedio de Alba baja de 30 a 0.2 × 1 + 0.8 × 31 = 25 ms y se evitan 10 M × 0.2 = 2 M inferencias al día; pero las dos GPUs siguen haciendo falta.
Caché de Actions para capas
GitHub Actions cache (type=gha)
Un almacén de caché de GitHub que sobrevive entre corridas. Con cache-from y cache-to: type=gha, el build de Docker guarda ahí sus capas y las reusa aunque la máquina nazca vacía.
La caché de build vive en el disco de la máquina que construye, y un runner de GitHub nace vacío en cada job. cache-to: type=gha,mode=max sube las capas a la caché de Actions al terminar (con mode=max, también las de etapas intermedias, como la que instala paquetes), y cache-from: type=gha las baja en la siguiente corrida. GitHub da, por omisión, 10 GB por repositorio (más se paga aparte) y borra lo que no se usa en 7 días: sobra para imágenes chicas y se queda corto para una de varios GB.
Ejemplo. El job imagen del gateway de Alba usa type=gha: un cambio de código reconstruye solo la capa de ≈ 48 KB. La imagen de Triton (≈ 9.2 GB) casi llenaría ella sola esos 10 GB.
Caché de build
build cache
Las capas que Docker guarda de builds anteriores, para reusarlas si el paso que las hizo no cambió. Si un paso cambia, se rehacen él y todos los que le siguen en el Dockerfile.
La llave de cada paso depende de la del paso anterior, del texto de la instrucción y, en un COPY, de los bytes de los archivos. Docker compara bytes, no significado: un comentario nuevo en requirements.txt rehace la instalación. En un RUN solo mira el texto, así que RUN apt-get update se reusa mientras su texto y lo de arriba no cambien, aunque pasen meses. La regla: lo que cambia poco arriba, lo que cambia en cada commit abajo.
Ejemplo. En el gateway de Alba, cambiar una línea de main.py cuesta ≈ 2–5 s y una capa de ≈ 48 KB, porque el código se copia después del pip install. Con COPY . . antes de instalar, cada cambio cuesta ≈ 30–60 s y ≈ 160 MB.
Caché de la CPU
CPU cache · L1, L2, L3
Memorias pequeñitas y muy rápidas dentro del chip de la CPU que guardan copia de lo que se usó hace poco. Si el dato está ahí (un acierto), llega en unos pocos nanosegundos; si no (un fallo), hay que ir a la RAM, la memoria principal, ≈ 100 ns.
Hay varios niveles (los números son de CPUs de 2022 a 2025). La L1, de 32 a 128 KiB por núcleo, responde en ≈ 1 ns; la L2, de ≈ 1 a 16 MiB, en ≈ 3 a 5 ns; la L3, de decenas de MiB o más y compartida por todos los núcleos o por un grupo de ellos, en ≈ 10 a 30 ns. El hardware la llena solo, sin que el programa lo pida, y nunca trae un byte suelto: trae una línea de 64 bytes seguidos (128 en los chips de Apple). Por eso importa la localidad: recorrer los datos en el orden en que están guardados aprovecha cada línea. Unos pocos fallos mandan sobre el promedio: 95 % de aciertos a 1 ns y 5 % de fallos a 100 ns dan ≈ 6 ns por lectura. La GPU tiene sus propias cachés junto a sus núcleos.
Analogía. La mesa junto a la estufa: lo que está ahí se usa sin esperar. Se rompe en que la mesa la acomodas tú; la caché la llena el hardware solo, y cuando pides un jitomate te sube la caja entera.
Ejemplo. Una línea de 64 bytes trae 16 números float32. Recorrer por filas una matriz de 1,024 × 1,024 float32 da 65,536 fallos; por columnas, si no cabe en la caché, 1,048,576: 16 veces más.
Caché de pasos de un pipeline
step cache
Guardar 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.
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.
Caching allocator
caching allocator
El repartidor de memoria de GPU de PyTorch: cuando un tensor se borra, no le devuelve su memoria al driver (el programa que maneja la GPU), sino que la aparta para el siguiente tensor. Por eso nvidia-smi, la herramienta de NVIDIA que muestra la memoria, ve la GPU más llena de lo que está.
Pedirle memoria al driver es lento, así que PyTorch se queda con la que ya pidió. Dos números lo describen: torch.cuda.memory_allocated(), lo que ocupan los tensores vivos, y torch.cuda.memory_reserved(), lo que PyTorch ya pidió, ocupado o apartado. nvidia-smi ve lo reservado más el contexto de CUDA (de 0.3 a 0.8 GB en las T4 de Alba). Si un tensor no cabe ni en lo apartado ni en lo libre, sale un OOM de CUDA (torch.cuda.OutOfMemoryError), que el programa puede atrapar. torch.cuda.empty_cache() devuelve lo apartado que nadie usa, para que otro proceso lo use, pero no libera tensores vivos ni arregla un OOM propio; llamarlo en cada request solo hace que cada request pida memoria otra vez. Una fuga se ve en memory_allocated creciendo request tras request.
Ejemplo. nvidia-smi marca 9.5 GB en una T4; memory_allocated da 1.2 GB y memory_reserved 8.8 GB. Hay 7.6 GB apartados que el siguiente batch puede reusar y 0.7 GB de contexto de CUDA: no es una fuga.
Cadena de suministro (de software)
software supply chain
Todo lo que entra a producción sin pasar por la revisión de tu equipo: bibliotecas, imágenes base, modelos preentrenados, las herramientas que arman y despliegan el código (el CI).
Casi todo lo que corre en un sistema lo escribió alguien más. Eso no es malo, pero cambia la pregunta: no basta con «¿mi código es seguro?», hay que poder contestar «¿lo que corre es exactamente lo que revisé?». En machine learning se suma un riesgo propio: un archivo de pesos puede ejecutar código al abrirse. Los controles van en cadena: dependencias fijadas con hash, SBOM y escaneo, procedencia (de un artefacto), firma del digest, política de admisión, credenciales de vida corta para el CI y pesos en formatos que no ejecutan, con su huella.
Ejemplo. El gateway de Alba trae 37 dependencias (contando las transitivas, las que traen las otras) dentro de una imagen que parte de python:3.13-slim. Si cada una tuviera una probabilidad de 0.001 de llegar comprometida en un año (supuesto), la de que llegue al menos una sería 1 − 0.999³⁷ ≈ 3.6 %.
Calibración
calibration
Que la seguridad del modelo sea honesta: de todas las veces que dice 90 %, que acierte 90 de cada 100.
Se revisa agrupando las predicciones por confianza y comparando con lo que acertó en cada grupo; el ECE lo resume en un número. Las redes modernas suelen ser demasiado confiadas; el temperature scaling (dividir los logits entre un número antes del softmax) lo corrige sin cambiar cuál clase queda primero. Importa cuando el número se usa para decidir: ordenar sugerencias, aplicar un umbral o calcular un costo.
Ejemplo. En 300 fotos el modelo dijo ≈ 90 % y acertó 246: 82 %. Exagera. El gate de Alba (el examen que decide si un modelo nuevo reemplaza al actual) pide ECE ≤ 0.05.
Cambio de contexto
context switch
Lo que hace el sistema operativo para pasar un núcleo de la CPU de un hilo (una línea de ejecución) a otro: guarda por dónde iba el que sale y carga el estado del que entra. Toma del orden de microsegundos.
El planificador del kernel lo hace cuando se acaba el turno de un hilo, cuando el hilo se bloquea (espera la red, el disco o un candado) o cuando despierta uno más urgente. Guarda los registros de la CPU, entre ellos en qué instrucción iba y dónde está su pila, y carga los del siguiente; entre hilos de procesos distintos, cambia también el mapa de memoria. Cada cambio es barato, pero miles por segundo se notan, y el hilo que entra encuentra fría la caché. Gracias a él, una máquina de 10 núcleos corre miles de hilos «a la vez».
Ejemplo. Si un cambio cuesta ≈ 3 µs, 1,000 cambios por segundo se llevan 3 ms de cada segundo de un núcleo (0.3 %); 20,000, 60 ms (6 %).
Camino del log
log pipeline
El recorrido de cada línea de log desde que el programa la escribe hasta donde alguien la lee: la salida estándar (stdout), el archivo del nodo, un recolector como Fluent Bit y el almacén. Nunca debe frenar la request.
El programa escribe a la salida estándar y sigue; el runtime del contenedor guarda la línea con su hora en un archivo del nodo; un recolector (Fluent Bit, como DaemonSet) la lee, la junta y la sube con un buffer en disco. Si el almacén falla, se pierden líneas y se avisa, pero el servicio sigue: se degrada el monitoreo, no la respuesta. Después, un job la reescribe en Parquet para consultarla barato.
Ejemplo. En Alba: stdout → archivo del nodo → Fluent Bit → s3://ml-datos/logs/crudo/… (gzip cada ≈ 5 min) → monitoreo-diario a la 01:00 UTC → Parquet en logs/predicciones/dt=…/model_version=…/; LogsStale avisa si en 30 min no llega nada.
Camino offline
offline path · training path
Todo lo que prepara la siguiente versión del modelo sin que nadie esté esperando: juntar y etiquetar datos, entrenar, examinar y aprobar. Su reloj son las horas, los días y las semanas.
Corre por calendario o cuando algo lo dispara, como el drift o una categoría nueva. Si falla, nadie lo nota ese día: el modelo actual sigue respondiendo, solo que envejece. Se une al camino online por dos puentes: el registro de cada predicción (de online a offline) y el deploy (de offline a online).
Ejemplo. En Alba, cada mes: se guarda una muestra de las fotos, se juntan sus categorías (unas 5 mil revisadas a mano), se reentrena en unas horas de GPU, se examina contra el modelo actual y, si no es peor, se despliega.
Camino online
online path · serving path
Todo lo que pasa mientras alguien espera una respuesta: llega la petición (request), se prepara la entrada, el modelo calcula y sale la respuesta. Su reloj son los milisegundos.
Corre por cada request, a cualquier hora, y si falla se nota al instante. Por eso vive con un presupuesto de latencia, un tiempo máximo de espera y un fallback. Crece con el tráfico: más requests por segundo piden más copias encendidas. La pregunta que lo define: ¿alguien está esperando la respuesta?
Ejemplo. En Alba: la foto de Ana entra a la API, se prepara, el modelo hace la inferencia y regresa las 5 categorías más probables. 99 de cada 100 veces, en menos de 200 ms.
Campo receptivo
receptive field
El pedazo de la foto original que puede influir en una neurona. Crece con cada capa, y más rápido con stride.
Se calcula capa por capa con dos números, el campo r y el salto j (píxeles de la foto entre dos neuronas vecinas): r nuevo = r + (k − 1) × j y j nuevo = j × s, empezando con r = 1 y j = 1. Es un máximo teórico: los píxeles del centro pesan mucho más que los de la orilla. Decide si una red alcanza a ver un objeto grande y si un detalle chico sobrevive.
Ejemplo. Tres capas de 3 × 3 con stride 1 ven 3, 5 y 7 píxeles. Un número del último mapa de la ResNet-50 puede depender de 427 × 427 píxeles.
Canal
channel
Una de las cuadrículas de números que forman una imagen. Una foto RGB tiene tres canales: la cuadrícula de los rojos, la de los verdes y la de los azules.
Una foto en blanco y negro tiene un canal; un PNG con transparencia tiene cuatro (RGBA: el cuarto dice qué tan opaco es cada píxel). Un modelo como el de Alba, el marketplace que sigue el curso, espera exactamente tres, así que todo se convierte a RGB antes de entrar.
Ejemplo. La foto de Ana, ya preparada, son 3 canales de 224 × 224: 50,176 números rojos, 50,176 verdes y 50,176 azules.
Canary
canary release
Mandar una parte chica del tráfico real a la versión nueva, por etapas, y avanzar solo si en cada etapa se ve tan bien como la estable, comparando las dos en el mismo periodo de tiempo.
El porcentaje lo pone un proxy con pesos (en Alba, el ALB), no el número de pods: con 2 pods estables y 1 nuevo, el reparto por pods da ≈ 33 %. El canary reparte por request, así que mide salud (errores, latencia, confianza) pero no el comportamiento de cada usuario, que pide una prueba A/B por usuario. Cada etapa dura lo suficiente para juntar su n mínimo y cubrir el pico del día, y sus criterios se escriben antes. El nombre viene de los canarios que los mineros bajaban para detectar gas.
Ejemplo. El de Alba para un modelo: 5 % por 4 h (17.5 requests por segundo en el pico), 25 % por 4 h (87.5), 100 %, sin pausa manual; lo ejecuta Argo Rollouts.
Capa
layer
Un grupo de neuronas que reciben las mismas entradas, cada una con sus propios pesos. Lo que sale de una capa entra a la siguiente.
En una capa densa (dense, fully connected o linear) cada neurona ve todas las entradas: tiene entradas × salidas pesos más un sesgo por salida, y hace entradas × salidas multiplicaciones-sumas por ejemplo. En una capa convolucional cada filtro ve solo un pedacito (convolución). Una red de capas densas es un MLP.
Ejemplo. Una capa densa de 2,048 entradas y 500 salidas tiene 2,048 × 500 + 500 = 1,024,500 parámetros: es la cabeza de la ResNet-50 de Alba, el marketplace del curso, que elige entre 500 categorías.
Capa de la imagen
image layer
Uno de los pedazos apilados de una imagen de contenedor: un archivo comprimido con los archivos que un paso de la receta agregó, cambió o borró. Se identifica por la huella SHA-256 de sus bytes, un número que cambia si cambia un solo byte.
Cada RUN, COPY o ADD del Dockerfile agrega una. Al arrancar el contenedor se montan una encima de otra y el proceso ve un solo árbol. Como se identifican por su huella, se comparten: diez imágenes sobre la misma base guardan esa base una vez, y un nodo no baja una capa que ya tiene. Borrar un archivo en una capa posterior solo lo tapa: la imagen pesa igual y el archivo sigue en la capa de abajo.
Analogía. Una hoja de acetato con solo lo nuevo, puesta sobre las otras en un proyector. Se rompe al borrar: el parche tapa, pero la hoja de abajo sigue en la pila.
Ejemplo. El gateway de Alba tiene tres capas que pesan: la base python:3.13-slim (≈ 43 MB), el entorno con 37 paquetes (≈ 44 MB comprimido, ≈ 160 MB en disco) y el código (≈ 48 KB). Cambiar una línea de código solo cambia la última.
Capacidad
capacity
El throughput más alto (requests terminadas por segundo) que un servidor sostiene cumpliendo su presupuesto de latencia. No es lo más que alcanza a procesar: pasado ese punto todavía procesa más, pero tarde.
No se adivina: se mide con una prueba de carga en rampa, con el mismo hardware, la misma configuración y datos reales, y es el último escalón cuyo p99 cabe en el presupuesto del tramo. Con ella se cuentan máquinas: m=⌈λpico÷(K×ρobj)⌉+R, el pico entre la capacidad K por la utilización objetivo, redondeado hacia arriba, más el repuesto. Lo que se deja libre a propósito es el headroom.
Ejemplo. Una T4 de Alba con la ResNet-50 en TensorRT: ≈ 1,200 fotos por segundo, el último escalón de la prueba de carga con un p99 chico, ≈ 28 ms. A 1,300 todavía procesa ≈ 1,210, pero con un p99 de ≈ 130 ms.
Capas de red
network layers · L2, L3, L4, L7
La manera de repartir el trabajo de la red en pisos, donde cada protocolo responde una sola pregunta: el enlace llega al siguiente aparato (L2), IP a la máquina (L3), TCP o UDP al programa (L4) y HTTP dice qué se pide (L7).
Cada capa usa la de abajo sin saber cómo funciona, y envuelve lo que le da la de arriba en su propio encabezado, como sobres dentro de sobres: HTTP dentro de TCP, dentro de IP, dentro de Ethernet o Wi-Fi. Los números vienen de un modelo de siete capas, el OSI (internet se diseñó con uno de cuatro, el de TCP/IP, con las mismas capas de arriba); en el trabajo se usan sobre todo L3, L4 y L7. Importan porque lo que ve un aparato depende de su capa: un router lee IPs; un balanceador de capa 4 ve IPs y puertos y reparte conexiones; uno de capa 7 abre HTTP y reparte requests.
Ejemplo. Un paquete de 1,500 bytes del gateway a Triton lleva 20 bytes de IP, 20 de TCP y 1,460 de datos; el primero, además, el encabezado de HTTP con POST /v2/models/classifier/infer. El Service de Kubernetes reparte en L4: ve conexiones, no requests.
CapEx contra OpEx
capex vs opex
CapEx es una compra grande que se usa varios años y se reparte (amortiza) en ellos, como un servidor. OpEx es el gasto que se paga mes con mes, como la luz o la renta de la nube.
La nube convierte CapEx en OpEx: no pones el dinero por adelantado ni apuestas a cuánta capacidad necesitarás en tres años. A cambio, pagas el margen del proveedor y el gasto sigue mientras uses. La comparación honesta pone las dos cosas en la misma unidad, US$ al mes: compra ÷ meses de vida + operación, contra precio por hora × horas de uso. El punto donde se igualan dice cuántas horas al mes necesitas usar lo propio para que convenga.
Ejemplo. Un servidor de ≈ US$24,400 que dura 36 meses es CapEx de 24,400 ÷ 36 ≈ US$678 al mes en los libros. Las dos T4 de Alba, el marketplace que sigue el curso, son OpEx: 2 × 0.526 × 730 ≈ US$768 cada mes que estén prendidas.
Cardinalidad (de las métricas)
cardinality
Cuántas series crea una métrica: el producto de los valores posibles de sus etiquetas, por las series de cada combinación. Una etiqueta con un valor por request la hace crecer sin techo.
Con etiquetas de v1,v2,… valores hay K=v1×v2×… combinaciones; un contador da 2×K series y un histograma de b bordes, (b+4)×K. Todo se multiplica por los pods. Cada serie cuesta memoria, índice y muestras, y Prometheus se cae si crecen sin límite. No es la cardinalidad de un join (cuántas filas salen al unir dos tablas), aunque se llame igual.
Ejemplo. El gateway de Alba tiene 239 series por pod (≈ 2,900 con 12 pods). Con el request_id como etiqueta de la latencia serían 15 × 10 M = 150 millones de series nuevas al día.
Carga abierta
open-loop load · open model
Una manera de generar tráfico en una prueba: las requests llegan a una tasa fija, pase lo que pase con las respuestas. Se parece a los usuarios reales.
Su contrario es la carga cerrada (closed-loop): N usuarios virtuales que mandan su siguiente request cuando reciben la respuesta de la anterior. La cerrada se frena junto con el servidor y mide menos requests justo en los peores momentos, así que su p99 sale mejor que la realidad: es la coordinated omission. Para medir latencia a una tasa dada se usa carga abierta (k6 con tasa fija, wrk2, perf_analyzer por tasa); para encontrar el máximo, sirve la cerrada.
Ejemplo. Un servidor de 10 ms con una pausa de 1 s, en una prueba de 10 s a 1,000 requests por segundo: la carga cerrada reporta un p99 de 10 ms; la abierta, de ≈ 0.9 s.
Cargo por datos procesados
data processing charge
Lo que cobra un servicio de la nube por cada GB que pasa por él, aparte de sus horas, salga o no el dato de la nube. Lo cobran el NAT gateway, los endpoints privados de pago (interface endpoints) y SageMaker AI (la plataforma de modelos de Amazon), entre otros.
No es egress (transferencia de salida): se cobra aunque los datos no salgan de la nube y en cualquier dirección. Tarifas en us-east-1: NAT gateway ≈ US$0.045 por GB; interface endpoint ≈ US$0.01; SageMaker AI hosting ≈ US$0.016 de entrada y de salida. El ALB cobra algo parecido por sus LCU (≈ US$0.008 por GB cuando ganan los bytes). Se encuentra multiplicando bytes por request × requests al mes en cada flecha.
Ejemplo. Bajar una imagen de 9.2 GB por el NAT: 9.2 × 0.045 ≈ US$0.41 por arranque; 60 arranques al mes ≈ US$25.
Casi duplicado
near-duplicate
Dos ejemplos que no son el mismo archivo pero muestran lo mismo: la misma foto recortada, vuelta a comprimir o más clara. Una huella exacta del archivo (hash) no los detecta; hace falta comparar lo que se ve, con una huella perceptual o con embeddings.
Si un casi duplicado queda en train y su gemelo en test, el modelo acierta de memoria: es leakage. Para copias exactas basta un hash del archivo, como sha256, que cambia por completo si cambia un solo byte. Para casi copias se usa una huella perceptual (el average hash, pHash y parientes): se calcula sobre una versión diminuta de la imagen, en gris, y cambia poco si la imagen cambia poco. Dos fotos son casi duplicadas si sus huellas difieren en pocos bits. También se pueden comparar sus embeddings con similitud coseno.
Ejemplo. Barz y Denzler (2020) encontraron que el 3.3 % de las imágenes de test de CIFAR-10 y el 10 % de las de CIFAR-100 (dos datasets públicos de fotos chiquitas) tenían un casi duplicado en train. En Alba, el marketplace del curso, la misma foto en tres publicaciones.
Categoría nueva
new class
Una clase que el negocio agrega y que el modelo actual no puede predecir, porque no tiene una salida para ella ni ejemplos. Se siembra con etiquetas a mano y obliga a reentrenar.
Las sugerencias nunca la dicen, así que casi no hay labels débiles buenos para ella. Se buscan ejemplos (por ejemplo, por título) y se mandan a la cola hasta juntar unos cientos. El modelo necesita una salida más en su última capa y entrenar con esos ejemplos. También cambia la validación: el rango de ids válidos crece en uno.
Ejemplo. El 1 de octubre de 2026 Alba agregó «bolsas», la categoría 501: el label_id válido pasó de 0–499 a 0–500, y la cola reserva 10 % (500 fotos) para llegar a ≈ 200–500 bolsas etiquetadas.
CD: entrega y despliegue continuos
continuous delivery · continuous deployment
Llevar lo que pasó el CI (las pruebas automáticas de cada cambio) hasta producción sin pasos a mano. En la entrega continua todo queda listo y una persona aprieta el botón; en el despliegue continuo sale solo.
Las dos comparten lo importante: el artefacto se construye una sola vez en el CI y ese mismo pasa por cada ambiente (staging, luego producción), con una prueba de humo en cada paso y una forma probada de volver (rollback). En producción se entra poco a poco, con un canary o un blue-green. El despliegue continuo exige más confianza en las pruebas y en ese freno, pero no es más arriesgado si están: los cambios llegan chicos y de uno en uno. Con GitOps, el último paso es un PR que cambia la imagen (su tag y su digest) en un repositorio; en Alba lo abre y lo junta un programa, una GitHub App, y la aprobación humana está antes, en el pipeline.
Analogía. Una línea de producción de pasteles: cada pastel pasa por las mismas revisiones y sale empacado y listo. En la entrega continua, alguien decide cuándo abre la tienda; en el despliegue continuo, el pastel llega solo al aparador. Se rompe en que un pastel malo vendido no se puede «revertir», y un despliegue sí.
Ejemplo. El gateway de Alba, del merge al clúster en ≈ 17.5 minutos más la aprobación humana (con tiempos supuestos para varias etapas): pruebas, imagen y su push, paridad de punta a punta en una T4 que se prende para eso, staging con humo y producción de pod en pod. Un modelo nuevo además pasa por shadow de 1 a 2 días y un canary 5 % → 25 % → 100 %.
CDC (change data capture)
change data capture
Leer cada inserción, cambio y borrado de una base de datos desde su registro interno y publicarlo como un evento, sin tocar el código de la aplicación. Ejemplo: Debezium hacia Kafka.
Toda base de datos seria anota cada cambio en su propio registro antes de aplicarlo. Una herramienta de CDC lee ese registro y publica los cambios en un stream, así otros sistemas (el data lake, un índice de búsqueda) se enteran sin consultar la base cada rato. Resuelve la escritura doble (guardar en la base y publicar en Kafka, donde una puede fallar sin la otra). Su pariente es el patrón outbox: el servicio escribe el evento en una tabla de la misma base, dentro de la misma transacción, y un proceso aparte lo publica.
Ejemplo. Cada cambio de precio en la tabla de publicaciones de un marketplace sale por CDC como un evento a Kafka, y el índice de búsqueda lo aplica en segundos.
CDN
content delivery network
Una red de servidores repartidos por el mundo que guardan copias de contenido y lo entregan desde el más cercano al usuario. Es un proxy inverso con caché, en el borde de internet.
Acorta el viaje: en vez de cruzar miles de kilómetros hasta el servidor de origen, la respuesta sale de una ciudad cercana. Sirve para lo público y repetido: imágenes, el código de una página, videos, el archivo de un modelo que se descarga una app. De paso aguanta picos y ataques de tráfico lejos de tus servidores. No sirve para lo que es nuevo o privado en cada request, como una inferencia.
Ejemplo. Las fotos de las publicaciones de Alba, el marketplace del curso, que ve mucha gente, se sirven desde una CDN. La request que clasifica cada foto, no: cada foto es nueva y privada, y su respuesta depende de ella.
Centro de datos
data center
Un edificio lleno de servidores acomodados en racks (estantes metálicos), con electricidad de respaldo, enfriamiento y varias conexiones de fibra. La nube vive ahí: son las computadoras de alguien más.
Resuelve lo que una oficina no resuelve: electricidad que llega por más de una línea, baterías y generadores para cuando se va, enfriamiento para miles de servidores que se calientan, y fibra por caminos distintos. Un proveedor agrupa sus centros de datos en zonas (uno o más edificios con luz y red propias) y las zonas en regiones. También se renta espacio dentro de uno para poner servidores propios (colocation).
Ejemplo. Cuando el equipo de Alba, el marketplace que sigue el curso, dice «us-east-1a», habla de uno o más centros de datos reales en el norte de Virginia, donde están sus máquinas.
Certificado
certificate · X.509
Un documento digital que une un nombre (como api.alba.example) con una llave pública, con fechas de validez, firmado por una autoridad certificadora que comprobó que quien lo pidió controla ese nombre.
Es lo que resuelve el ataque del intermediario: el cliente no acepta cualquier llave pública, solo una que venga en un certificado de una cadena que termina en una raíz de su almacén de confianza, con el nombre que pidió y sin vencer. El nombre que cuenta es el del campo Subject Alternative Name. Los certificados públicos duran cada vez menos: 200 días como máximo desde marzo de 2026, 100 desde marzo de 2027 y 47 desde marzo de 2029; por eso se renuevan solos (con ACME, el protocolo de renovación automática, o con ACM, el servicio de certificados de AWS). En mTLS, también el cliente presenta uno.
Analogía. Una credencial de elector: tu nombre, tu foto y un sello del organismo que la emitió. Dónde se rompe: una credencial se revisa a ojo; un certificado lo revisa una cuenta de firmas, y se puede copiar sin problema, porque sin la llave privada no sirve de nada.
Ejemplo. El certificado de api.alba.example, válido del 1 de octubre de 2026 al 16 de abril de 2027 (198 días, lo que emite ACM; el máximo es 200), firmado por una CA intermedia, que a su vez está firmada por una raíz que ya trae el sistema operativo.
cgroup
control group · cgroup
Una función de Linux que junta procesos (programas corriendo) en un grupo y le pone límites: cuánta memoria, cuánta CPU, cuántos procesos. Es lo que hace cumplir los limits de Kubernetes y el --memory de Docker.
Se ve como una carpeta en /sys/fs/cgroup, con archivos como memory.max (bytes) y cpu.max (cuota y ventana). La memoria es un tope duro: si el grupo se pasa, el OOM killer del kernel mata con SIGKILL a un proceso del grupo (en Kubernetes, a todo el contenedor), y sale con código 137 (oom). La CPU es una cuota: con un límite de 1 CPU, el grupo puede usar 100 ms de CPU en cada ventana de 100 ms, sumando todos sus hilos; si se la acaba, se congela hasta la siguiente ventana (throttling): no muere, se vuelve lento a ráfagas. Ojo: os.cpu_count() de Python cuenta los núcleos del nodo, no la cuota del cgroup.
Ejemplo. El gateway de Alba tiene un límite de memoria de 1 GiB y ninguno de CPU. Con 4 fotos de 40 ms de CPU a la vez y un límite de 1 CPU, la cuota de 100 ms se acaba a los 25 ms y cada foto tardaría 100+(160−100)/4 = 115 ms en vez de 40.
Champion y challenger
champion / challenger
Los dos papeles de los modelos en producción: el champion (campeón) es el que atiende a la gente; el challenger (retador) es el nuevo que se está probando para reemplazarlo.
Todo el camino de un modelo nuevo es un challenger tratando de quitarle el lugar al champion: el gate lo compara contra él en el mismo examen, el canary le da una parte del tráfico y, si gana, se vuelve el champion. En un registro de modelos los dos papeles son alias: nombres que señalan a una versión y se mueven. El champion anterior no se borra: es a donde se vuelve si algo sale mal.
Ejemplo. En noviembre de 2026, en Alba, champion señala a la versión 14 (resnet50-2026-10-01) y, cuando el candidato termine de exportarse, challenger señalará a la 15 (resnet50-2026-11-01).
Check obligatorio
required status check
Una regla de la rama principal: un pull request (PR) no se puede juntar (merge) si cierto job no terminó en verde. Convierte el rojo de CI de consejo en regla.
Se configura en las reglas de la rama (branch protection o rulesets en GitHub) con el nombre del check. Tiene una trampa: si el workflow no corre en un PR (por ejemplo, porque filtra con paths: y el PR no toca esa carpeta), el check nunca reporta y el PR se queda esperando. Un job saltado con if sí cuenta como aprobado. Por eso la condición va en el if del job, no en el disparador del workflow.
Ejemplo. En alba/classifier, pruebas es obligatorio. Un PR que solo cambia config.pbtxt igual corre gateway.yml, porque el workflow no filtra por carpetas.
Checkpoint
checkpoint
Un archivo con el estado del entrenamiento en un momento: los parámetros, el estado del optimizador y en qué paso iba. Sirve para seguir si algo falla y para quedarse con la mejor versión.
Uno completo lleva las perillas, el estado del optimizador (en Adam, m y v), la época y el paso, el estado del scheduler, el del GradScaler (la pieza que ajusta la escala de los gradientes) si se entrena en precisión mixta (con números de 16 y de 32 bits) y el de los generadores de azar. Con solo las perillas se puede responder, pero no seguir el mismo entrenamiento. Guardarlo seguido permite usar máquinas spot, que el proveedor puede reclamar con poco aviso.
Ejemplo. Alba, el marketplace que sigue el curso, guarda uno cada 15 minutos: 24.5 M parámetros × 4 bytes ≈ 98 MB, más el estado de Adam (2 × 98 MB), ≈ 294 MB en total.
Checksum
checksum
Una huella corta y rapidísima (una suma de verificación) para detectar datos dañados por accidente, como un bit que se volteó en un disco o en un cable. No protege contra alguien que quiera engañarte.
El más común es CRC32, de 32 bits, que va en cada archivo ZIP y PNG y en los paquetes de Ethernet; en Python, zlib.crc32. Detecta con seguridad un bit volteado y cualquier ráfaga de hasta 32 bits dañados seguidos. Pero con 32 bits, por la paradoja del cumpleaños, dos archivos distintos chocan tras ≈ 77,000 intentos, y la cuenta permite incluso ajustar un archivo para que dé el CRC que uno quiera. Para identificar contenido o para seguridad se usa un hash criptográfico.
Ejemplo. En una prueba, voltear un solo bit de una «foto» de 204,800 bytes cambia su CRC32 de fa8191cc a 13143f88; pero dos archivos de 16 bytes al azar con el mismo CRC32 aparecen en una fracción de segundo.
Chequeo que bloquea y chequeo que avisa
blocking vs warning check
Un chequeo que bloquea detiene el pipeline cuando falla; uno que avisa deja seguir y alerta a una persona. Bloquea lo que invalidaría al modelo; avisa lo que solo es raro.
Bloquear no apaga el servicio: detiene el modelo nuevo y sigue el actual. Avisar sirve para lo discutible, como una categoría que creció mucho por una campaña real. Todo chequeo nuevo empieza avisando, para ver con datos reales si su umbral está bien puesto antes de dejarlo detener el entrenamiento.
Ejemplo. En Alba bloquean: esquema roto, label_id fuera de rango, una foto en dos splits (en train y en validación a la vez), volumen fuera de 0.8–1.5 veces, datos de hace más de 48 h y labels débiles por encima de 80 %. Avisan: una categoría que creció > 30 % y un slice (un grupo de fotos que se mide aparte) debajo de su piso.
CHW
channels, height, width
El orden en que se acomodan las dimensiones de una imagen: primero el canal, luego el alto y luego el ancho. Es el que esperan PyTorch (la librería más usada para entrenar redes) y el modelo de Alba.
Las librerías de imágenes (Pillow, OpenCV) suelen dar HWC: alto, ancho y los 3 números de cada píxel juntos. Pasar de uno a otro es reacomodar los mismos números. Con un grupo de imágenes adelante se escribe NCHW: cuántas, canales, alto, ancho.
Ejemplo. HWC: (224, 224, 3). CHW: (3, 224, 224). Mismos 150,528 números, otro orden.
Cifrado
encryption
Convertir datos legibles en bytes que parecen ruido, con una llave secreta, de forma que solo quien tiene la llave los regrese a como estaban.
Lo que se protege es el texto en claro; lo que sale, el texto cifrado. El método (el algoritmo, como AES) es público: la seguridad está solo en la llave (principio de Kerckhoffs). Un cifrado básico da confidencialidad; para detectar cambios hace falta un modo autenticado (AES-GCM) o una firma, y para saber con quién hablas, un certificado. Se aplica a lo que viaja (en tránsito, con TLS) y a lo que se guarda (en reposo, con KMS).
Analogía. Un candado de combinación: el modelo del candado lo conoce todo el mundo; la combinación, solo tú. Dónde se rompe: un candado se puede cortar; un buen cifrado no tiene un atajo así, solo probar llaves.
Ejemplo. La foto de Ana, cifrada con AES-128 y una llave de 16 bytes, se ve como bytes al azar. Con la llave, vuelve a ser la misma foto, byte por byte.
Cifrado de sobre
envelope encryption
Cifrar cada archivo con su propia llave de datos y guardar esa llave, cifrada con la llave maestra de KMS (el servicio de la nube que guarda llaves y nunca las entrega), junto al archivo. Como meter la llave del candado en un sobre que solo KMS abre.
Existe porque KMS solo cifra hasta 4,096 bytes y cada llamada viaja por la red. Tres pasos: pedir una llave de datos (GenerateDataKey), cifrar localmente con AES y borrar la copia en claro, y para leer, mandar a KMS solo la llave cifrada (Decrypt). Cada Decrypt pasa por la política de la llave y queda en el registro. Rotar la llave maestra no obliga a recifrar los archivos.
Ejemplo. Un archivo de 1 GB serían ≈ 244,141 llamadas a Encrypt de 4,096 bytes. Con sobre, una llamada para guardarlo y una para leerlo.
Cifrado en reposo
encryption at rest
Cifrar lo guardado: archivos en S3 (el almacén de archivos de AWS), discos, bases de datos y respaldos. Protege contra quien se lleve el disco o un respaldo; no contra quien entra con los permisos de tu programa.
En la nube casi siempre está prendido (S3 cifra todo objeto nuevo desde enero de 2023). Su valor real no es el disco robado, sino separar dos permisos: leer los bytes y usar la llave. Con las llaves en KMS y su política, quien tenga permiso sobre el bucket todavía necesita permiso sobre la llave, y cada uso queda en un registro de auditoría.
Ejemplo. Todo bucket de Alba usa SSE-KMS con una llave de Alba para fotos y logs. Un rol que puede leer el bucket pero no tiene kms:Decrypt recibe Access Denied.
Cifrado en tránsito
encryption in transit
Cifrar lo que viaja por una red, para que nadie en el camino lo lea ni lo cambie. En la práctica es TLS, el protocolo que cifra conexiones (o mTLS entre servicios).
La pregunta de diseño no es si se cifra, sino dónde empieza y dónde termina cada tramo cifrado, y qué protege los que no lo están (una red privada, reglas de red). Lo que sale a internet o a otra organización debe ir siempre cifrado. Dentro de una red privada es una decisión de riesgo y costo. Se complementa con el cifrado en reposo: uno cuida lo que se mueve; el otro, lo guardado.
Ejemplo. En Alba van por TLS el tramo del caller (el programa que llama a la API) al ALB (el balanceador de entrada) y todo lo que sale de un pod (a S3, a proveedores). Del ALB al gateway y del gateway a Triton, sin cifrar dentro de la red privada.
Circuit breaker
circuit breaker
Un contador dentro del cliente que, si un servicio del que depende falla demasiado, deja de llamarlo un rato y contesta de inmediato con el plan B. Tiene tres estados: cerrado, abierto y semiabierto.
Cerrado: deja pasar las llamadas y cuenta fallas y timeouts. Abierto: no llama; cada request recibe el fallback al instante. Semiabierto: deja pasar unas pocas llamadas de prueba; si salen bien se cierra, si no vuelve a abrirse. No salva requests, pero libera los recursos del cliente, da el plan B mucho más rápido y deja que la dependencia se recupere sin carga, lo que corta una tormenta de reintentos. Lleva un mínimo de llamadas para no abrirse por dos fallas de madrugada. La idea la popularizó Michael Nygard en su libro Release It! (2007).
Analogía. La pastilla del tablero eléctrico, que corta la corriente si pasa demasiada. Se rompe en que la pastilla salta con un solo pico y espera a que alguien la suba; el breaker de software cuenta una tasa y se prueba solo (semiabierto).
Ejemplo. Unos números de ejemplo típicos: se abre con más de 50 % de fallas en los últimos 10 s y al menos 20 llamadas; se queda abierto 30 s; semiabierto, prueba con 5. Con el Triton de Alba caído entero y sin contestar, a 500 requests por segundo, baja de 500 × 0.15 s = 75 requests esperando a Triton a 500 × 0.001 s = 0.5 en vuelo, y el plan B llega en ≈ 1 ms en vez de ≈ 150.
Claims
claims
Lo que afirma un token: quién es (sub), quién lo emitió (iss), para quién es (aud), cuándo caduca (exp) y qué permite (scope), entre otros. En un JWT van en un JSON firmado.
Los nombres cortos vienen del estándar: iss (issuer), sub (subject), aud (audience), exp (expiration) e iat (issued at), en segundos desde 1970, y jti, un id único del token que sirve para revocarlo. Se pueden agregar otros, como scope. Revisar la aud evita aceptar un token que el emisor dio para otro servicio. Cualquiera que tenga el token los lee, así que no llevan secretos ni datos personales que no hagan falta.
Ejemplo. Un token con "aud": "busqueda" llega al clasificador: la firma es buena y exp está en el futuro, pero no es para él. Lo rechaza con 401.
Clase de almacenamiento
storage class
Cada manera de guardar un objeto en el mismo object storage, más cara o más barata según qué tan seguido y qué tan rápido lo vas a leer. En S3, el de Amazon, van de Standard (US$0.023 por GB al mes, precio de lista del norte de Virginia en 2026) a Glacier Deep Archive (≈ US$0.001), con la misma durabilidad.
Lo que cambia es el trato: cuánto cuesta guardar, cuánto cuesta leer y cuánto hay que esperar. Standard se lee al instante, sin cargo por GB. Standard-IA (Infrequent Access) cuesta casi la mitad, pero cobra US$0.01 por GB leído, un mínimo de 30 días y un mínimo de 128 KB por objeto. Glacier Instant Retrieval cuesta ≈ US$0.004 y cobra US$0.03 por GB leído, con mínimos de 90 días y 128 KB por objeto. Glacier Flexible Retrieval y Deep Archive son para archivo: leerlos tarda de minutos a horas. Mover un objeto de clase es una request que se cobra por objeto, así que con millones de objetos chicos mover puede costar más de lo que ahorra. Intelligent-Tiering mueve cada objeto solo, según su uso, por una cuota pequeña. Las mueven las reglas de ciclo de vida. Google tiene la misma escalera: Standard, Nearline, Coldline y Archive.
Ejemplo. La copia de los vectores de un servicio de búsqueda por foto pesa ≈ 205 GB por versión: 205 × US$0.023 ≈ US$4.7 al mes en Standard y 205 × US$0.004 ≈ US$0.82 en Glacier Instant Retrieval. Leer una versión entera desde Glacier IR para reconstruir el índice cuesta 205 GB × US$0.03 ≈ US$6.15.
Clasificación
classification
La tarea de elegir de una lista fija de clases. Puede ser binaria (sí o no), multiclase (una de muchas) o multietiqueta (varias a la vez).
El modelo da un puntaje (logit) por clase. En la multiclase, softmax los vuelve probabilidades que suman 1 y gana la más alta (argmax); en la clasificación binaria y la multietiqueta, cada logit pasa por una sigmoide y un umbral decide. Las clases se fijan al entrenar: el modelo no puede elegir una que no estaba en su lista.
Ejemplo. Un filtro de spam (2 clases), la categoría de una foto en Alba, el marketplace del curso (500 clases), o las 7 políticas de un sistema de moderación de contenido (multietiqueta).
Clasificación binaria
binary classification
Clasificación con solo dos clases: sí o no. ¿Este pago es fraude? ¿Este correo es spam?
Casi siempre el modelo da un solo logit, la sigmoide lo vuelve la probabilidad del «sí» y un umbral decide. A la clase que buscas (fraude, spam) se le dice positiva; a la otra, negativa. Suele haber desbalance de clases: en un ejemplo típico de detección de fraude, el fraude es ≈ 0.08 % de los pagos, así que decir siempre «no» ya acierta 99.92 %.
Ejemplo. Logit 2 → sigmoide 0.881 → con umbral 0.5, «sí, es spam».
Client credentials
client credentials grant
El flujo de OAuth para máquinas: un programa se presenta ante el proveedor de identidad con su client_id y su secreto (o un certificado) y recibe un token de acceso, sin ninguna persona de por medio.
Es la manera estándar de autenticar llamadas de servicio a servicio. El programa hace un POST al endpoint de tokens con grant_type=client_credentials y el scope que pide; la respuesta trae el access_token, su tipo (Bearer) y expires_in. El secreto vive en un gestor de secretos y se usa solo al renovar, no en cada request: lo que viaja es el token corto.
Ejemplo. El servicio de moderación de Alba pide su token con grant_type=client_credentials&scope=classify y recibe uno con expires_in: 900, 15 minutos. Lo usa en todas sus requests al clasificador y pide otro a los 12.
Cliente
client
En una conexión por la red, el programa que la abre y pide algo. El otro lado, el que estaba esperando, es el servidor.
El cliente hace connect a la IP y al puerto de un servidor; el kernel le presta un puerto efímero para que la respuesta tenga a dónde volver. Ser cliente o servidor es un papel en cada conexión, no un tipo de máquina: el mismo programa puede ser las dos cosas en conexiones distintas. Como el cliente abre la conexión, es él quien paga el handshake, y por eso le conviene reusar conexiones.
Ejemplo. En Alba, la app de Ana es cliente del backend; el backend, cliente del ALB; el gateway es servidor para el ALB y cliente de Triton.
Cliente de Triton (tritonclient)
Triton client
La biblioteca de Python con que un programa le habla a Triton: arma los tensores de entrada, los manda por HTTP o gRPC y lee los de salida. Se crea uno por proceso, con su pool de conexiones.
tritonclient trae clientes para HTTP y gRPC, normales y asíncronos. Un InferInput describe cada tensor (nombre, forma y tipo, como "input", [1, 3, 224, 224], "FP32"), y con binary_data=True lo manda con la extensión binaria. Se crea uno al arrancar, en el lifespan (arranque y cierre), y se reusa: adentro tiene un pool de conexiones con keep-alive. Trampa: el parámetro timeout de infer() no es un plazo del cliente; son microsegundos que se le mandan a Triton para su fila. El plazo real se pone con asyncio.wait_for.
Ejemplo. El gateway de Alba crea un InferenceServerClient asíncrono con conn_limit=64 y lo llama con asyncio.wait_for(..., min(0.15, lo que queda)). Con Triton trabado, 500 llamadas por segundo × 0.15 s = 75 llamadas abiertas a la vez, ≈ 15 por copia: caben en 64.
CloudWatch
Amazon CloudWatch
El servicio de AWS que guarda métricas y logs de sus propios productos, como el balanceador, y deja poner alarmas sobre ellas. Ve lo que pasa antes de que una request llegue a tu código.
Cada producto de AWS publica ahí sus métricas sin que hagas nada. Para un ALB: RequestCount, TargetResponseTime, HTTPCode_Target_4XX_Count y _5XX_Count (lo que contestaron los pods) y HTTPCode_ELB_5XX_Count (lo que contestó el propio ALB). Cubre los puntos ciegos del servicio: lo que nunca llegó a sus métricas.
Ejemplo. Si todos los pods del gateway de Alba fallan su probe de readiness, el ALB contesta 503 él mismo; el gateway no cuenta nada, pero la alarma ALB5xx de CloudWatch despierta a la guardia al pasar de 0.5 % en 5 minutos.
CNN
convolutional neural network
Una red neuronal hecha sobre todo de convoluciones, activaciones y pooling. Es la familia clásica para imágenes.
Le va bien a las fotos por tres razones: cada filtro mira cerca (el significado está en los píxeles vecinos), usa el mismo filtro en todas partes (reconoce un tenis esté donde esté, con pocos parámetros) y arma lo complicado con lo simple, capa tras capa, porque su campo receptivo crece. La ResNet-50 con la que Alba, el marketplace del curso, sugiere la categoría de cada foto es una CNN.
Ejemplo. Una capa convolucional de 64 filtros de 3 × 3 sobre la foto de color tiene 1,792 parámetros; una capa densa de 1,000 neuronas sobre los mismos 150,528 números tendría ≈ 150 millones.
Cobertura
code coverage
La parte del código que corrió mientras corrían las pruebas, casi siempre en porcentaje de líneas. Dice qué no se probó; nunca dice que lo probado esté bien.
La de líneas cuenta qué líneas se ejecutaron; la de ramas (branch coverage), más exigente, pide que en cada if se haya recorrido el camino del sí y el del no. En Python se mide con coverage.py o con pytest --cov (del complemento pytest-cov); las ramas se cuentan con coverage run --branch o --cov-branch. Sirve como alarma: encuentra un except o una rama que ninguna prueba toca. No sirve como meta: una línea puede correr sin que nadie revise su resultado, y un equipo al que le exigen 100 % termina escribiendo pruebas que corren líneas sin revisar nada.
Ejemplo. Una función de resize con un error, max en vez de min, llega a 100 % de cobertura con una prueba de foto cuadrada (donde min y max coinciden) y otra de foto chiquita. El error sigue ahí: nadie la probó con una foto vertical.
Codificación
encoding
Convertir un dato que no es un número (una categoría, un texto) en números que el modelo pueda usar, sin inventarle relaciones que no tiene.
Un modelo solo multiplica y suma, así que todo le tiene que llegar como número. Para una categoría hay varias formas: one-hot (una columna de 0 y 1 por valor), números en orden (solo si el orden existe de verdad, como las tallas chica, mediana y grande), hashing (una fórmula fija manda cada valor a una de un número fijo de casillas, útil cuando hay millones de valores) y embeddings (una lista de números aprendida para cada valor). La codificación se decide con los datos de entrenamiento (train) y se usa idéntica al servir.
Ejemplo. El giro del comercio en un modelo de fraude: supermercado = [1, 0, 0], gasolinera = [0, 1, 0], videojuegos = [0, 0, 1]. En uno de clics en anuncios, el id de cada anuncio cae por hashing en una de 2²⁴ = 16,777,216 casillas.
Código de estado
status code
El número de tres cifras de la primera línea de una respuesta de HTTP. Dice qué pasó: 2xx salió bien, 3xx está en otro lado, 4xx tu request está mal y 5xx el servidor falló.
La primera cifra es la familia, y con ella se sabe de quién es la culpa. Un 4xx (400, 401, 403, 404, 405, 413, 415, 422) va a fallar igual si se repite, así que no se reintenta y no cuenta contra el SLO; la excepción es el 429 (te pasaste de tu cuota), que se reintenta después de Retry-After. Un 5xx dice que el servidor falló: el 503 (estoy lleno o me falta algo) se reintenta después de Retry-After; el 502 y el 504 los responde un intermediario cuando quien está detrás contesta mal o no contesta a tiempo; el 500 suele ser un bug. El 202 dice «lo recibí, el resultado después». Hay convenciones fuera del estándar, como el 499 de nginx: el cliente se fue antes de la respuesta.
Ejemplo. Alba: 413 si la foto pasa de 10 MB, 415 si no es JPEG, PNG ni WebP, 422 si top_k vale 0, 503 si Triton no está disponible y 504 si no contesta en 150 ms. Con un 503 o un 504, el backend muestra el selector manual.
Código de salida
exit code · exit status
El número de 0 a 255 que deja un programa al terminar. 0 quiere decir que todo salió bien, y cualquier otro, que algo falló. Si lo mató una señal del sistema operativo, vale 128 más el número de la señal: 137 = 128 + 9, la de SIGKILL.
Lo lee el padre: la terminal (echo $?), Docker o el kubelet. Del 1 al 125 los define cada programa (1 es el error de siempre; Python sale con 1 si una excepción no se atrapa). El 126 y el 127 los pone la shell de la terminal (no se pudo ejecutar, no existe). De 128 en adelante, 128 + n quiere decir «lo mató la señal n»: 130 es Ctrl+C, 137 es SIGKILL, 139 es SIGSEGV y 143 es SIGTERM. Cabe en un byte, así que da la vuelta: sys.exit(256) sale con 0. El subprocess de Python lo da en negativo (−9 en vez de 137). Kubernetes lo muestra en kubectl describe pod como Exit Code, junto con la razón, por ejemplo OOMKilled.
Ejemplo. Exit Code 137 con Reason OOMKilled: el contenedor pasó su límite de memoria y el kernel lo mató. 137 es 128 + 9, la señal SIGKILL.
Cola acotada
bounded queue
Una fila con un límite, por cuántas caben o por cuánto pueden esperar. Si está llena, la request nueva se rechaza en el momento, en vez de esperar para nada.
Una fila sin tope nunca falla: solo se atrasa en silencio cuando llega más de lo que el servidor procesa, hasta que todo vence su timeout y el goodput cae a cero. El tope va donde se rompe el presupuesto de latencia, no donde se acaba la memoria. Un tope por número también acota el tiempo, por la Ley de Little: lugares ÷ throughput. Es la forma más simple de backpressure.
Ejemplo. Alba pone topes en cada salto: 16 requests en vuelo por pod del gateway, 2 decodes a la vez con 50 ms de espera máxima, y la fila de Triton que rechaza lo que ya esperó 100 ms.
Cola de etiquetado
labeling queue
La lista de fotos que se paga a personas para etiquetar en un periodo, con su tamaño, su mezcla y su presupuesto.
Se arma con active learning: una parte al azar (muestra aleatoria, sorteada primero), las dudosas, los desacuerdos y las categorías nuevas. Una parte va con doble anotación y otra son preguntas de control. Se entrena con todo lo etiquetado, pero se evalúa solo con lo que no se eligió a propósito.
Ejemplo. En Alba son ≈ 5,000 fotos al mes: 1,250 al azar, 2,000 dudas (confianza del top-1 < 0.3, o menos de 0.1 entre el top-1 y el top-2), 1,250 desacuerdos y 500 de categorías nuevas. Con 10 % dobles, ≈ US$275–550 y ≈ 31–46 horas al mes; las ≈ 250 preguntas de control van encima, con ≈ US$13–25 aparte.
Cola de mensajes
message queue
Un servicio que guarda mensajes en fila hasta que un consumidor los toma, hace el trabajo y confirma que terminó. Cada mensaje lo procesa un solo consumidor, y al confirmarlo se borra. Ejemplos: SQS (de Amazon), RabbitMQ y Pub/Sub (de Google).
Separa a quien pide un trabajo (el productor) de quien lo hace (el consumidor): el productor deja el mensaje y sigue, y los consumidores lo toman a su ritmo. El broker guarda cada mensaje en disco, con copias, hasta que alguien lo confirma con un ack. Al entregarlo no lo borra: lo esconde durante el visibility timeout, y si no llega el ack, vuelve a la fila. Por eso la entrega normal es at-least-once. Los mensajes llevan una referencia (un job_id y la llave del archivo), no el archivo. No es lo mismo que una fila en la memoria de un proceso, como la del batcher de Triton o queue.Queue de Python, que se pierde si el proceso se reinicia.
Analogía. Las comandas colgadas en la ventanilla de una cocina: el mesero no espera al cocinero, varios cocineros toman comandas y una comanda que nadie terminó sigue ahí. Se rompe en que un cocinero que se desmaya no devuelve la comanda; en una cola, el mensaje vuelve solo cuando vence su plazo.
Ejemplo. La API recibe un PDF de 200 páginas, mete 200 mensajes (uno por página) y responde 202. Con 20 workers, a ≈ 1 s por página, el documento sale en ≈ 10 s en vez de ≈ 200 s.
Cola de una distribución
tail · tail latency
La parte larga y delgada de una distribución, donde quedan los pocos valores más extremos. En latencia, las requests más lentas: las que quedan arriba de los percentiles altos (p95, p99, p99.9).
La latencia tiene la cola a la derecha porque siempre se puede tardar más: una pausa del programa, un reintento, una fila de espera. La cola jala al promedio y decide el p99. A escala importa todavía más: con fan-out, la cola de cada pieza se vuelve la latencia típica del conjunto. No es lo mismo que la cola larga de categorías, que son muchas categorías con pocas fotos cada una.
Ejemplo. En 1,000 requests de juguete, la mediana es 38 ms, pero 29 requests pasan de 150 ms y la más lenta tarda 693: esa es la cola, y ahí está el p99, en 488 ms.
Cola larga
long tail
Cuando hay muchas categorías y la mayoría tiene pocos ejemplos: unas cuantas tienen decenas de miles y muchas, apenas cientos o decenas. Ordenadas de mayor a menor, forman una gráfica con una «cola» baja y larga.
El nombre viene de la gráfica: si ordenas las categorías de la más grande a la más chica, la curva cae rápido y luego sigue, baja y larga. Las grandes son la cabeza (head). Conviene medir la cabeza y la cola por separado, porque un modelo nuevo suele ganar en una y perder en la otra.
Ejemplo. Alba, el marketplace del curso, tiene 500 categorías y ≈ 1.84 M fotos de entrenamiento: 3,680 por categoría si se repartieran parejo, pero casi ninguna está cerca de ese promedio.
Comando
command
Lo que escribes en una línea de la terminal para pedir algo: una primera palabra, que es un programa o algo que la shell (el programa que lee lo que escribes) sabe hacer, seguida de sus argumentos.
La primera palabra puede ser un programa en el disco (ls es el archivo /usr/bin/ls, kubectl, python3) o un builtin, que la shell hace sin lanzar ningún proceso (cd, export, echo). cd tiene que ser builtin porque cambia la carpeta de la propia shell. type ls dice cómo va a entender la shell una palabra; which ls dice la ruta del programa. Lo demás de la línea son sus argumentos.
Ejemplo. type cd responde cd is a shell builtin; type ls responde ls is /usr/bin/ls. Si la palabra no es ninguna de las dos, la shell dice «command not found» y deja el código 127.
Commit
commit
Una foto guardada del proyecto: la lista de sus archivos (el árbol), el id del commit anterior (su padre), el autor, la fecha y un mensaje. Su id es el hash (SHA-1, por omisión) de todo eso, así que cambiar cualquier cosa del pasado cambia todos los ids siguientes.
Git calcula el id con un hash criptográfico (SHA-1 por omisión, que se escribe con 40 caracteres hexadecimales) del texto del commit. Como ese texto incluye el id del padre, cada commit amarra toda la historia anterior: nadie puede cambiar el código de un commit y conservar su id. Se suele usar el hash corto, los primeros 7 caracteres (más si otro objeto empieza igual). El mismo contenido con el mismo autor, fecha, mensaje y padre da el mismo id en cualquier máquina. No es el COMMIT de una transacción de base de datos ni el commit de un offset en una cola: los tres dicen «esto queda firme», pero son cosas distintas.
Ejemplo. El commit «Sube el timeout a 0.20 s» son 213 bytes de texto; Git calcula el SHA-1 de commit 213, un byte en cero y esos bytes, y le salen los 40 caracteres que empiezan con 139f652. Con un carácter menos en el mensaje, el id es otro: c27a81e.
Comodín
wildcard · glob · globbing
Un carácter que la shell reemplaza por los nombres de archivo que coinciden con un patrón: * es cualquier texto, ? un carácter y [12] uno de la lista. El reemplazo pasa antes de lanzar el programa.
El programa nunca ve el patrón: recibe la lista de nombres ya hecha. Por eso ls *.log y ls "*.log" no son lo mismo: entre comillas, el patrón llega tal cual. Si no coincide con nada, bash pasa el patrón literal y zsh se niega a correr el comando (no matches found). Los patrones que son para otro programa van entre comillas: find . -name "*.log". Y un rm * en la carpeta equivocada borra todo lo que ahí coincida.
Ejemplo. Con gateway-1.log, gateway-2.log y triton.log en la carpeta, echo *.log imprime los tres y echo gateway-?.log, solo los dos primeros.
Comparaciones múltiples
multiple comparisons
Hacer muchas pruebas a la vez (métricas, slices, categorías) y fijarse en las que salen. Cada una trae su 5 % de falsa alarma: con 20 pruebas sin efecto, esperas una.
La probabilidad de al menos una falsa alarma en k pruebas independientes es 1 − (1 − α)^k, el complemento de que ninguna falle: con 20 a 0.05, ≈ 64 %. Defensas: una métrica primaria fijada antes, leer las demás como pistas y corregir el corte. Bonferroni usa α ÷ k en cada prueba; Holm es una versión menos estricta, la que usa Alba, el marketplace que sigue el curso, en su gate (el examen que decide si un modelo nuevo sale) sobre sus 100 categorías.
Ejemplo. Un A/B con 10 métricas, ninguna con efecto real: 1 − 0.95¹⁰ ≈ 40 % de probabilidad de que alguna salga «significativa».
Comparar corridas
comparing runs
Leer la diferencia entre dos entrenamientos (dos corridas) contra lo que ya se sabe que varía sin que nada cambie, para no confundir ruido con una regresión.
Dos corridas varían por dos ruidos distintos: el del entrenamiento (otra semilla da otro modelo) y el de la evaluación (el examen es una muestra). Comparar es poner la diferencia Δ=xB−xA junto a la tolerancia: si cabe, es ruido; si no, algo de los cinco ingredientes cambió y se comparan los punteros de las dos corridas (commit, snapshot de datos, imagen). Decidir si un modelo nuevo es mejor es otra cosa: lo hace el gate con las predicciones foto por foto y una prueba pareada.
Ejemplo. Dos corridas de Alba con la misma receta dan 85.3 % y 85.1 % en el golden set. Δ = −0.2 puntos y la tolerancia es τ ≈ 0.26: no es regresión, es la misma receta con distinto azar.
Compilar
compile
Traducir un programa completo, antes de correrlo y una sola vez, a instrucciones de máquina: las órdenes simples que entiende la CPU. Lo hace otro programa, el compilador, y el resultado es un binario ejecutable, un archivo que se arranca directo.
Los lenguajes compilados (C, C++, Go, Rust) pagan la traducción una vez y después corren a toda velocidad, porque la CPU ejecuta el resultado directo. El precio: un binario por cada arquitectura y sistema operativo, y volver a compilar con cada cambio. Python hace otra cosa: lo corre un intérprete. La palabra también se usa con modelos: TensorRT compila un modelo en un engine hecho para un modelo de GPU y una versión de TensorRT, y torch.compile compila partes de un modelo de PyTorch mientras el programa corre.
Ejemplo. Triton se compila desde C++ al binario tritonserver. El modelo de Alba se compila con TensorRT a un engine FP16 para la T4: si la versión no coincide, Triton no arranca y el pod queda en CrashLoopBackOff (arranca, falla y se reinicia una y otra vez).
Complemento
complement
La probabilidad de que algo no pase: 1 − p. Su gran uso es «al menos uno»: P(al menos uno) = 1 − P(ninguno).
Sale de que «pasa» y «no pasa» cubren todos los casos y suman 1. Contar todas las formas en que «al menos uno falla» es engorroso; su contrario, «todos funcionan», es una sola cuenta con la regla del producto. Así salen el fan-out, 1 − 0.99^N, y la redundancia, 1 − (1 − a)^k. También es el paso entre una disponibilidad y su tiempo caído: 99.9 % disponible es 0.1 % caído.
Ejemplo. Dos servicios, cada uno lento 1 de cada 10 veces: al menos uno lento es 1 − 0.9 × 0.9 = 0.19. Sumar 0.1 + 0.1 = 0.2 cuenta dos veces el caso en que los dos son lentos.
Compresión
compression
Escribir los mismos datos con menos bytes, cambiando lo repetido por referencias cortas y lo frecuente por códigos chicos. Sin pérdida, al descomprimir salen los mismos bytes exactos; con pérdida, como en las fotos JPEG, se tira lo que casi no se nota.
Los compresores sin pérdida (gzip y zlib, que vienen con Python, zstd, snappy, lz4) son los únicos aceptables para logs, datasets y pesos: un byte distinto es un dato equivocado. Los de pérdida, como el de JPEG, son para fotos, audio y video. Comprimir tiene un límite: la entropía de los datos. Lo repetido casi desaparece; lo que parece al azar, como un hash o un archivo ya comprimido, no se achica y hasta crece un poco. Cada compresor elige un punto entre tamaño y velocidad: comprimir más cuesta más CPU. En un formato columnar, cada columna se comprime aparte y gana mucho más.
Ejemplo. 10,000 líneas de log de mentiras (1,149,280 bytes) quedan en 83,178 con zlib nivel 9, 13.8 veces menos; la misma cantidad de bytes al azar crece a 1,149,641.
Compute capability
compute capability
El número con que NVIDIA identifica la arquitectura de cada generación de GPUs: 7.5 para la T4 (sm_75), 8.9 para la L4. Un engine de TensorRT construido para una no carga en otra.
Cada generación de GPUs de NVIDIA entiende su propio juego de instrucciones, y se identifica con un número: 7.5 la T4, 8.0 la A100, 8.6 la A10G, 8.9 la L4, 9.0 la H100. Se escribe también sm_75, sm_89… Los kernels se compilan para una o varias de esas arquitecturas. Un engine es más estricto todavía: sus kernels se eligieron cronometrando en esa GPU. Por eso un engine se construye para cada tipo de GPU donde se va a servir.
Ejemplo. El engine de Alba es para sm_75, la T4. Si Alba agregara L4 (sm_89), haría falta un segundo engine, otra imagen y una regla para mandar cada imagen a su tipo de máquina.
Compute-bound
compute-bound
Cuando lo que frena un cálculo es la velocidad de los núcleos y no la memoria: los datos llegan a tiempo y el chip calcula a su máximo. Se acelera con menos operaciones (FLOPs) o con un chip más rápido (más FLOPS).
En español, «limitado por el cálculo». Pasa cuando la intensidad aritmética del cálculo es mayor que el punto de quiebre de la GPU: cada byte que llega se usa en tantas operaciones que la memoria alcanza a alimentar a los núcleos. Lo son las multiplicaciones de matrices grandes, el prefill de un LLM, que procesa todo el prompt de una vez, y, en buena parte de sus capas, una CNN con batches moderados. Palancas: menos FLOPs (menos resolución, un modelo más chico), tensor cores de menor precisión (FP16, INT8, FP8) o una GPU con más TFLOPS. Una GPU con más ancho de banda no lo acelera.
Ejemplo. Dos matrices de 4,096 × 4,096 en FP16 en una T4: calcular toma al menos ≈ 2.1 ms (137 GFLOPs ÷ 65 TFLOPS) y mover sus ≈ 101 MB, ≈ 0.3 ms (a 320 GB/s). Manda el cálculo.
Concept drift
concept drift · deriva de concepto
Cuando cambia la regla que une la entrada con la respuesta correcta: la misma foto o el mismo pago ahora merecen otra respuesta, aunque los datos de entrada se vean idénticos.
En notación, cambia p(y | x): la probabilidad de cada respuesta y dada una entrada x. En un concept drift puro las entradas no se mueven, así que el PSI de las entradas puede quedarse en cero mientras el modelo empeora. Solo se ve con etiquetas nuevas (la métrica cae) o con señales indirectas, como más correcciones de personas. Las etiquetas viejas quedan mal: se reetiqueta con la regla nueva y se reentrena. No es lo mismo que el drift de datos (cambian las entradas) ni que el label shift (cambia cuánto hay de cada clase).
Ejemplo. En Alba, el equipo de moderación decide que las fundas de celular ya no van en «Celulares», sino en «Accesorios para celular»: la misma foto, otra respuesta correcta. En la detección de fraude en pagos, los defraudadores aprenden los cortes y compran a US$95–99, justo debajo del corte de US$100: la misma compra ahora es fraude más seguido.
Concurrencia
concurrency
Tener varias tareas en curso al mismo tiempo, aunque en cada instante avance solo una. Ayuda cuando las tareas esperan: mientras una espera, otra usa la CPU.
Es una forma de organizar el trabajo, no de hacerlo más rápido. Con trabajo de pura CPU en un núcleo, turnarse no baja el tiempo total y empeora el promedio. Con esperas (la red, el disco, otro servicio), sí ayuda: el gateway de Alba atiende otras requests mientras espera a Triton, el servidor del modelo. Se logra con hilos, con procesos o con un event loop. No es lo mismo que el paralelismo, que necesita varios núcleos: todo paralelismo es concurrencia, pero no al revés.
Analogía. Un mesero que atiende cinco mesas: toma una orden, la lleva a la cocina y, mientras se prepara, atiende otra mesa. Se rompe en que el mesero decide cuándo cambiar de mesa; con hilos, lo decide el planificador del sistema operativo.
Ejemplo. Cuatro requests del gateway con 6 ms de CPU y 10 ms de espera cada una: una tras otra, la cuarta sale a los 64 ms; concurrentes, en el mismo núcleo, a los 34 ms.
Concurrency (un despliegue a la vez)
concurrency group
Una opción de un job o workflow que agrupa corridas por nombre: dentro de un grupo, solo una corre a la vez. Con cancel-in-progress se decide si la nueva cancela a la vieja o espera.
Dos despliegues al mismo ambiente a la vez se pisan: copias de dos versiones mezcladas y un estado que nadie pidió. concurrency: { group: <nombre> } hace que las corridas del mismo grupo no se encimen: por omisión, una corre y una espera; si llega otra, la que esperaba se cancela (con queue: max esperan en orden, hasta 100). Con cancel-in-progress: true, la nueva cancela a la que va a la mitad, que sirve para las pruebas de un PR al que llegó otro push; para un despliegue se usa false, porque cortar un despliegue a medias es peor que esperar.
Ejemplo. El job produccion de Alba usa el grupo deploy-gateway-produccion con cancel-in-progress: false: si dos merges llegan seguidos, el segundo despliegue espera al primero.
conda
conda
Un gestor de paquetes y entornos nacido en el mundo científico cuyos paquetes no son solo de Python: también instala compiladores, librerías de C, el toolkit de CUDA (para programar GPUs de NVIDIA), el lenguaje R y el propio Python.
Cada entorno de conda es una carpeta con todo eso adentro. Los paquetes salen de canales: el de Anaconda, la empresa que lo creó, que desde 2020 pide licencia de pago a las organizaciones de más de 200 personas, contando contratistas (sus términos vigentes son de julio de 2025), y conda-forge, comunitario y libre. mamba y micromamba son versiones más rápidas del mismo programa. Conviene cuando necesitas piezas que no son Python y pip no da, o en un clúster donde no eres root; casi nunca en la imagen de un servicio, porque las wheels ya traen su código compilado y la imagen slim con pip o uv es más chica. Una trampa clásica: mezclar conda install y pip install en el mismo entorno, porque conda no sabe lo que pip cambió.
Ejemplo. El gateway de Alba no usa conda: su imagen es python:3.13-slim con un entorno de pip en /opt/venv, ≈ 87 MB comprimida.
Confianza
confidence score
La probabilidad que un modelo le da a su opción favorita, la del primer lugar. Es lo seguro que dice estar, no una garantía de que acierte.
También se le dice score o score top-1. Un modelo puede estar muy seguro y equivocado, sobre todo ante fotos distintas a las de su entrenamiento: softmax siempre reparte el 100 % entre las clases que conoce. Si está bien calibrado, de cada 100 respuestas con 94 % acierta unas 94. Ojo: en estadística, «intervalo de confianza» es otra cosa.
Ejemplo. «Tenis, 94 %»: la confianza es 0.94. En Alba, el marketplace del curso, se llama baja confianza a un top-1 menor que 0.3.
config.pbtxt
model configuration
El archivo de configuración de un modelo en Triton, en el formato de texto de protobuf: el motor, las entradas y salidas, el batch máximo, el batching, la fila, las copias y el warmup (las corridas de calentamiento).
Cada campo es una decisión. platform dice qué motor corre el archivo; max_batch_size, el batch más grande, que no puede pasar del perfil del engine; input y output, nombres, tipos y dims sin el eje del batch (Triton antepone -1); dynamic_batching, cuánto esperar para juntar requests y qué hacer con las que esperan demasiado (política de la fila); instance_group, cuántas copias y dónde (grupo de instancias); model_warmup, qué correr antes de decir «listo».
Ejemplo. El de Alba: tensorrt_plan, max_batch_size: 32, input FP32 [3, 224, 224], logits FP32 [500], batching de 2 ms con tamaños preferidos 16 y 32, fila con REJECT a 100 ms, 2 copias en la GPU y warmup de 3 corridas con un batch de 32 en ceros.
ConfigMap
ConfigMap
Un objeto de Kubernetes (el sistema que reparte programas entre máquinas) que guarda configuración como pares nombre-valor dentro del clúster, para dársela a los programas que corren ahí (sus pods) como variables de entorno o como archivos montados.
Se declara en YAML con un campo data, donde todos los valores son texto. Un pod lo usa con envFrom (cada llave se vuelve una variable de entorno) o montándolo como carpeta (cada llave, un archivo). La diferencia importa al cambiarlo: una variable de entorno se copia al arrancar y el proceso que ya corre no se entera (hay que reiniciar, por ejemplo con kubectl rollout restart); un archivo montado lo actualiza el kubelet con un retraso de alrededor de un minuto, salvo si se montó con subPath. Guarda a lo mucho 1 MiB. No es para secretos: para eso está el Secret.
Ejemplo. gateway-config, en el namespace classifier, con TRITON_URL: "triton.classifier:8000", INFER_TIMEOUT_S: "0.15" y PREPROCESS_CONCURRENCY: "2".
Configuración
configuration · config
Los valores que un programa lee para decidir cómo portarse y que pueden cambiar sin tocar el código: una dirección, un timeout, un umbral, una contraseña. El código dice qué hacer; la configuración, con qué valores.
Lo que cambia entre ambientes (laptop, staging, producción) o entre días se saca del código para que la misma imagen corra en todos lados, byte por byte. Llega por variables de entorno, archivos (casi siempre en YAML) o flags, con una precedencia clara, y se revisa completa al arrancar (validación). No es configuración lo que obliga a cambiar otra cosa al mismo tiempo: el preprocesamiento o el orden de las categorías son parte del código o del modelo. La parte que da acceso es un secreto y se trata aparte.
Ejemplo. El gateway de Alba lee TRITON_URL (triton.classifier:8000; en producción el nombre lleva la versión del modelo, como triton-v14), INFER_TIMEOUT_S=0.15 y PREPROCESS_CONCURRENCY=2. En la laptop, el mismo código habla con otro Triton y espera más.
Conflicto de merge
merge conflict
Lo que pasa cuando dos ramas cambiaron las mismas líneas del mismo archivo (o líneas pegadas) de manera distinta: Git no adivina cuál quieres, marca el pedazo en el archivo y se detiene para que decidas.
El pedazo en disputa queda entre marcadores: de <<<<<<< HEAD a ======= está tu versión, y de ahí a >>>>>>> otra-rama, la de la rama que estás uniendo. git status --short muestra el archivo con UU. Se resuelve editando el archivo (tu versión, la otra o una tercera), borrando los marcadores, con git add y con git commit; git merge --abort deshace el intento. Lo difícil suele ser la decisión, no Git. Se evitan con ramas cortas, cambios chicos y trayendo seguido lo nuevo de main.
Ejemplo. Luis sube INFER_TIMEOUT_S a 0.25 en su rama y Ana lo baja a 0.10 en main: al unir, config.py queda con las dos líneas entre marcadores, y lo resuelven dejando 0.15.
Confusión de dependencias
dependency confusion
Subir a un índice público de paquetes (como PyPI) un paquete con el mismo nombre que uno interno de una empresa, y una versión más alta, para que el instalador elija el público.
Pasa cuando el instalador busca en varios índices (el privado y el público) y se queda con la versión más alta que encuentre en cualquiera. Se defiende con un solo origen para los paquetes (un índice privado o un proxy que la empresa controla), nombres internos reservados y dependencias fijadas con hash.
Ejemplo. Una empresa tiene alba-preprocess 1.4 en su índice privado. Alguien sube a PyPI un alba-preprocess 99.0. Un pip install que mire los dos índices instalaría el de PyPI.
Consentimiento
consent
El permiso de una persona para que uses sus datos personales. Vale si es libre (sin obligarla), informado (sabe qué pasará) y específico (para una finalidad concreta). Para datos sensibles, tiene que ser expreso; en México, además, por escrito.
No es la única base para tratar datos: también lo son cumplir un contrato con la persona, una obligación legal o, en Europa, un interés legítimo bien pesado. En Europa es una de seis bases al mismo nivel; en México es la regla general y la ley enumera las excepciones, y para datos no sensibles basta el consentimiento tácito (te mostraron el aviso y no te opusiste). Tiene un costo de diseño: se puede retirar en cualquier momento, y entonces hay que dejar de usar el dato y poder encontrar dónde está (el mapa de datos). «Expreso» quiere decir una acción clara, como marcar una casilla, no el silencio.
Ejemplo. Un sistema de transcripción de llamadas solo guarda la transcripción si quien organiza la llamada lo activa, y no entrena con el audio sin un consentimiento explícito.
Consistencia eventual
eventual consistency
La promesa de que, si dejan de llegar cambios, todas las copias de un dato terminan diciendo lo mismo; pero en un momento dado, dos copias pueden decir cosas distintas.
Lo contrario es la consistencia fuerte: cualquier lectura ve la última escritura confirmada. La fuerte es más cómoda y más cara, porque las copias tienen que ponerse de acuerdo antes de responder. Por eso las réplicas de lectura, muchas bases NoSQL y todo caché con TTL son eventualmente consistentes. DynamoDB lee así por omisión, y una lectura fuerte cuesta el doble. Funciona cuando un poco de atraso no daña (el precio que ve un comprador) y no cuando sí (un saldo). Borrar en un sistema así pide tombstones, para que el borrado también llegue a todas las copias. No es la C de ACID: esa habla de cumplir las reglas de la base.
Ejemplo. El carrito de Amazon, según el artículo de Dynamo de 2007, prefería aceptar siempre cambios y juntar las copias después; el precio era que a veces reaparecía un artículo que habías quitado.
Consola, CLI y API de la nube
console / CLI / API
Las tres maneras de pedirle cosas a la nube. Por debajo, todo es una API: cada acción es una request HTTP firmada a un endpoint del proveedor; la consola web y la CLI solo lo arman por ti.
La consola es una página con botones, buena para explorar y mala para repetir. La CLI es un comando de la terminal (aws, gcloud, az). El SDK es una biblioteca para tu programa (boto3 en Python). Cada request pasa por permisos (IAM) y cuota antes de crear algo, y la de EC2 es por región (ec2.us-east-1.amazonaws.com); algunas, como la de IAM, son globales. Como todo es API, la infraestructura se puede escribir en archivos y crear con una herramienta (infraestructura como código, como Terraform).
Ejemplo. aws ec2 run-instances --instance-type g4dn.xlarge … crea una de las VMs con GPU de Alba, el marketplace que sigue el curso; aws ec2 terminate-instances --instance-ids i-0123… la apaga y detiene el cobro.
Consumidor
consumer
El programa que saca mensajes de una cola o lee eventos de un stream y hace el trabajo. Casi siempre son varias copias iguales, que se reparten los mensajes.
En una cola, los consumidores compiten: cada mensaje se lo lleva uno solo, y al terminar lo confirma con un ack. En un stream, los consumidores se organizan en grupos: cada partición la lee un solo consumidor del grupo, que avanza su offset. Como la entrega normal es at-least-once, un buen consumidor es idempotente: procesar un mensaje dos veces deja el mismo resultado. Un worker (trabajador) que lee de una cola es un consumidor.
Ejemplo. Los workers de OCR de un servicio de documentos: cada uno recibe un mensaje, baja el PDF, escribe results/8f3a.json y solo entonces manda el ack.
Contador (counter)
counter
Una métrica que empieza en 0 y solo sube; vuelve a 0 si el proceso se reinicia. Su valor solo no dice mucho: lo útil es cuánto subió en un rato, con rate(), la función que da cuánto sube por segundo.
Cuenta eventos: requests, errores, bytes. Como nunca baja, una bajada se lee como reinicio: rate() e increase() suman los aumentos y, si el valor cae, cuentan el nuevo valor desde 0. Lo que el proceso viejo contó entre la última lectura y su caída se pierde. En el texto de /metrics va con _total, y el cliente de Python agrega _created, la hora en que nació la serie. Se saca primero la tasa de cada serie y después se suma: sum(rate(…)), nunca rate(sum(…)).
Ejemplo. Muestras cada 15 s de 1,000,000, 1,000,540, 1,001,080, 120 y 660: los aumentos son 540, 540, 120 y 540; en 60 s, 1,740 ÷ 60 = 29 requests por segundo.
Contenedor
container
Un paquete con tu programa y todo lo que necesita para correr (la versión de Python, las librerías, los archivos), para que corra igual en cualquier máquina.
Resuelve el clásico «en mi máquina sí funciona». La herramienta más usada para crearlos es Docker. Ojo: si el modelo usa una GPU, la máquina también necesita sus drivers (el programa que le permite al sistema operativo usar la tarjeta).
Analogía. Un contenedor de barco: no importa qué lleve adentro, tiene un tamaño estándar y cualquier puerto, grúa o barco lo puede mover. Se rompe en que un contenedor de software no es del todo independiente: usa partes del sistema operativo de la máquina donde corre, como los drivers de la GPU.
Ejemplo. El contenedor de la API de Alba lleva la versión exacta de Python, las librerías y el código. El mismo contenedor que se probó es el que corre en cada servidor.
Contenedor contra máquina virtual
container vs. virtual machine · VM · hypervisor
Un contenedor es un programa corriendo (proceso) al que el kernel le enseña solo su pedazo del sistema y le pone límites: todos los de una máquina comparten un kernel. Una máquina virtual simula una computadora completa, con su propio kernel, encima de un hipervisor, que reparte una máquina física en varias.
Los namespaces deciden qué ve el proceso: su propia lista de procesos (adentro es el PID 1), su red, su árbol de archivos, su nombre de máquina. Los cgroups deciden cuánto usa. Como el kernel es compartido, la imagen no trae kernel ni driver, arranca en menos de un segundo, más lo que tarde el proceso, y casi no gasta memoria de más; pero un error del kernel afecta a todos los contenedores del nodo. Una VM (máquina virtual) paga su propio kernel y su sistema completo (más memoria y un arranque de segundos a minutos) a cambio de aislar más: un atacante tendría que romper también el hipervisor. En la nube se usan las dos: una instancia de EC2 (las máquinas que renta AWS) es una VM, y adentro corren los contenedores.
Analogía. Departamentos en un mismo edificio contra casas separadas: los departamentos comparten cimientos, tubería y luz (el kernel); cada casa tiene los suyos. Se rompe en que un contenedor ni siquiera tiene paredes propias: es un proceso al que el kernel le oculta a los vecinos.
Ejemplo. En Alba, una g4dn.xlarge (una VM sobre el hipervisor Nitro de AWS) corre el contenedor de Triton, con Ubuntu 22.04, sobre el kernel de Amazon Linux 2023 de esa VM, junto al device plugin de NVIDIA.
Contenedor serverless
serverless container (Cloud Run / Container Apps)
Un servicio que corre tu imagen de contenedor completa, con su servidor web, y la escala según las requests, hasta cero. Cloud Run y Azure Container Apps, además, ofrecen GPU.
A diferencia de una función, corre lo que quieras dentro de tu imagen. Cloud Run ofrece L4 y RTX PRO 6000, una por instancia, en regiones limitadas; Container Apps, T4 y A100. Cobra más por hora que una GPU dedicada, pero solo las horas que la instancia está prendida (con GPU, incluidos hasta ≈ 10 minutos de espera después de la última request). Las instancias mínimas quitan el arranque en frío y se pagan siempre.
Ejemplo. Herramienta interna de moderación con ≈ 2 h de GPU al día, con el trabajo junto en lotes: ≈ US$64 al mes en Cloud Run contra ≈ US$588 de una L4 dedicada.
Contexto de build
build context
La carpeta que se le manda a Docker para construir una imagen: los únicos archivos que un COPY del Dockerfile puede ver. Todo lo que no se excluye viaja, aunque no se use.
Es el último argumento de docker build (docker build … gateway/). Un contexto con basura hace lento el build, puede romper la caché y, con un COPY . ., mete esa basura en la imagen. Lo que no debe viajar se lista en el .dockerignore.
Ejemplo. El contexto del gateway de Alba es la carpeta gateway/; su .dockerignore deja fuera las pruebas, .git/, el .env, las fotos y cualquier modelo.
Contrato de datos
data contract
El acuerdo escrito y ejecutable de cómo deben venir unos datos: columnas, tipos, rangos, frescura y quién es su dueño. Corre como código sobre cada partición (cada pedazo de la tabla, casi siempre un día) y dice si la cumple.
Junta pruebas de datos y les agrega quién responde y qué pasa cuando fallan: unos chequeos bloquean y otros avisan (chequeo que bloquea). El esquema tiene versión y un cambio que rompe se avisa antes. Lo ideal es que corra también del lado de quien produce los datos, en sus pruebas automáticas.
Ejemplo. El backend de publicaciones de Alba es dueño de los eventos suggestion_shown y category_selected, con esquema versionado; un cambio que rompe se avisa con 2 semanas. El chequeo de volumen bloquea si las filas del snapshot nuevo, divididas entre las del anterior, salen de 0.8–1.5.
Convergencia
convergence
Cuando el entrenamiento ya casi no mejora: la pérdida dejó de bajar y los pasos apenas cambian las perillas.
En un modelo de juguete, la perilla se acerca cada vez más al fondo y el gradiente, a 0. En uno real, con batches al azar, la pérdida nunca se queda quieta: tiembla alrededor de un nivel, y se dice que convergió cuando ese nivel deja de bajar. Bajar el learning rate al final ayuda a asentarse. Que la pérdida de entrenamiento converja no dice que el modelo sea bueno con datos nuevos: eso lo dice la validación.
Ejemplo. En una pérdida de juguete con una sola perilla, (2w − 6)², que empieza en w = 0, con lr = 0.05 la perilla queda a menos de 0.01 del fondo en 12 pasos; con lr = 0.005 tarda 140.
Convolución
convolution
Pasar un filtro chico (por ejemplo de 3 × 3) por toda la foto: en cada posición multiplica los píxeles que cubre por sus pesos, suma y escribe un número.
El mismo filtro se usa en todas las posiciones, así que una capa convolucional tiene muy pocos parámetros, encuentra un patrón esté donde esté y reutiliza cada peso miles de veces por foto. Cada filtro produce un mapa de activaciones, cuyo tamaño depende del stride y del padding. (En matemáticas, una convolución voltea el filtro antes de aplicarlo; las redes no lo voltean, pero se le sigue llamando así.)
Ejemplo. Un filtro con columnas 1, 0 y −1 sobre una ventana con filas 9 · 9 · 1, 8 · 9 · 0 y 9 · 8 · 1 da 8 + 8 + 8 = 24: hay un borde de claro a oscuro.
Cookie
cookie
Un dato chiquito que un servidor le pide al navegador guardar (con el header Set-Cookie) y que el navegador le regresa en cada request a ese sitio (con el header Cookie). Así una página recuerda que ya iniciaste sesión.
Es el parche a que HTTP no tenga memoria: la memoria no está en el protocolo, sino en un header que el navegador repite. La cookie suele llevar solo un identificador de sesión, y el servidor busca el resto en su base de datos. Opciones como HttpOnly (los scripts de la página no la pueden leer) y Secure (solo viaja por HTTPS) la protegen. Entre servicios casi no se usan: cada request lleva su credencial en Authorization. Un balanceador puede usar una cookie propia para mandar a la misma persona siempre al mismo grupo de servidores: una sesión pegajosa.
Ejemplo. El servidor responde Set-Cookie: sesion=ab12; HttpOnly; Secure, y desde entonces cada request del navegador a ese sitio lleva Cookie: sesion=ab12. Cuando Alba prueba una versión nueva del modelo, el ALB usa su cookie AWSALBTG para que un usuario no brinque entre la versión estable y la nueva.
Copia de tráfico
traffic mirroring
El mecanismo que manda una copia de cada request (o de una muestra) a un segundo destino, cuya respuesta se descarta. Es lo que hace posible un shadow (despliegue en sombra).
La copia se puede hacer en tres lugares: en el propio programa (el gateway decide y copia), en una malla de servicios (una capa de red que pone un programita, el sidecar, junto a cada servicio) o en la plataforma (un balanceador que la soporte). Donde sea, la regla es la misma: la copia no debe frenar ni cambiar la respuesta original. Por eso va en una tarea aparte, con su propio plazo y una cola acotada que tira copias si se llena. La muestra se elige con una asignación por hash para que sea repetible.
Ejemplo. El gateway de Alba calcula el SHA-256 del request_id, lee los primeros 8 caracteres de esa huella como un número y copia si ese número, módulo 10,000 (el residuo de dividir entre 10,000), da menos de 1,000: de 100,000 ids copia 9,955, casi el 10 %.
Corrida
run
Un entrenamiento anotado: lo que se decidió antes (parámetros), lo que se midió (métricas), etiquetas para encontrarlo (tags) y los archivos que produjo (artefactos).
La corrida es la unidad del seguimiento de experimentos. Tiene cuatro tipos de cosa: parámetros, que no cambian (el learning rate o lr, las épocas, la semilla, el id del snapshot de datos); métricas, que pueden tener un valor por paso o por época (curva de métricas por época); tags, textos para buscar y explicar (commit, digest de la imagen); y artefactos, archivos (el checkpoint final, labels.json). Las corridas se agrupan en experimentos. Un reintento debe reanudar la misma corrida, no abrir otra.
Ejemplo. La corrida resnet50-2026-10-01 de Alba guarda lr 3e-4, 8 épocas, batch 64, semilla 17 y ds-2026-09-01 como parámetros; la pérdida y val_top1 de cada época; el commit c3f2fc2 y el preproceso 1.4.0 como tags; y el checkpoint final de ≈ 294 MB como artefacto. Las de prueba llevan el sufijo -prueba-N.
Corrutina
coroutine
Una función que se puede pausar a la mitad y continuar después, donde se quedó y con sus variables intactas. En Python se define con async def, y cada await es un punto donde se pausa para que corra otra.
Llamar a una función async def no la corre: crea una corrutina, que alguien tiene que esperar con await o entregarle al event loop como tarea (asyncio.create_task, asyncio.gather). Solo dentro de otra corrutina se puede usar await. Pausarse y volver es mucho más barato que cambiar de hilo, y por eso un proceso puede tener miles de corrutinas esperando a la vez. Una corrutina suelta el turno solo en sus await: entre uno y otro, nadie más corre en ese loop.
Ejemplo. async def atender(): datos = await leer(); return await triton(datos) se pausa dos veces: mientras llegan los bytes y mientras responde Triton, el servidor del modelo. En esas pausas, el loop atiende a otras requests.
Costo por predicción
cost per prediction (per 1,000 predictions)
Lo que cuesta cada predicción, normalmente por cada 1,000: el precio por hora entre las predicciones que de verdad se hacen en esa hora. Manda la utilización: qué parte de lo que la GPU podría hacer le llega de verdad.
US$ por 1,000 = US$ por hora ÷ (predicciones por hora ÷ 1,000). Las predicciones por hora son las que llegan, no las que la GPU podría hacer. Por eso una GPU que trabaja al 5 % cuesta 20 veces más por predicción que a tope, con la misma factura. Es la manera correcta de comparar GPUs: una que cuesta el doble y atiende el triple sale más barata. Se mide con una prueba de carga con el modelo real.
Ejemplo. Alba, el marketplace del curso: 2 T4 cuestan ≈ US$768 al mes y, con ≈ 116 fotos por segundo, hacen ≈ 304.8 M predicciones, o 304,848 grupos de 1,000: 768 ÷ 304,848 ≈ US$0.0025 por 1,000, solo de GPUs (con toda la infraestructura, ≈ US$0.006). Una T4 a tope (≈ 1,200 por segundo) daría ≈ US$0.00012.
CPU
CPU · central processing unit · procesador
El procesador de una computadora: pocos núcleos muy capaces, de 8 a 16 en una laptop y decenas en un servidor, que hacen cualquier tipo de trabajo, uno tras otro, muy rápido.
Corre el sistema operativo, el código de Python, la lectura de archivos y la red. Al entrenar, la CPU prepara los batches (leer las fotos, decodificarlas, la data augmentation) y la GPU hace las cuentas. Si la CPU no alcanza a preparar los datos, la GPU se queda esperando. Algunos modelos, como los árboles de un pronóstico de demanda, se entrenan solo en CPU.
Ejemplo. Un pronóstico de demanda de supermercado, con ≈ 490 millones de filas, se entrena en una máquina de 96 vCPU (núcleos virtuales), unas 2 a 3 horas cada domingo.
CPU-bound
CPU-bound · limitado por la CPU
Un trabajo que tarda porque tiene muchas cuentas que hacer: mientras corre, un núcleo de la CPU está al 100 %. Se acelera con una CPU más rápida, repartiéndolo entre núcleos o calculando menos; aprovechar mejor las esperas no lo cambia, porque casi no espera.
Decodificar y redimensionar una foto, tokenizar texto en Python, armar un JSON enorme o correr un modelo en CPU son CPU-bound. Se reconoce porque el núcleo está al 100 % mientras tarda. En Python, varios hilos no aceleran un trabajo CPU-bound escrito en Python puro, por el GIL; sí lo aceleran varios procesos (multiproceso) o librerías escritas en C que sueltan el GIL, como Pillow, NumPy o PyTorch. Dentro de async (programación asíncrona), un trabajo CPU-bound congela al event loop: por eso va a un threadpool (grupo de hilos). No lo confundas con compute-bound, que dice si un chip, como la GPU, está limitado por calcular o por leer su memoria.
Ejemplo. El decode de una foto en el gateway de Alba, el marketplace del curso, cuesta ≈ 6 ms de CPU en promedio, y el de una foto web de 12 megapíxeles sin draft mode (el atajo que la decodifica ya reducida), de 40 a 80 ms. A 500 requests por segundo, son 500 × 0.006 s ≈ 3 vCPU ocupados todo el tiempo.
Credenciales temporales
temporary credentials
Credenciales que la nube entrega al asumir un rol y que caducan solas, normalmente en una hora. El programa pide unas nuevas antes de que venzan.
Lo contrario de una credencial estática (una llave de acceso que vale hasta que alguien la borre). Si se filtran, sirven minutos y no meses, y solo para lo que permite el rol. En AWS las da STS (Security Token Service), el servicio que cambia una prueba de identidad por credenciales. Son el último escalón de la escalera de secretos: «la mejor forma de manejar un secreto es no tenerlo».
Ejemplo. Una llave de AWS en un repositorio sirve hasta que alguien la rote; unas credenciales temporales copiadas de un log vencen en ≈ 1 hora.
Criterio de promoción
promotion criteria
La regla, escrita antes de empezar, que dice qué tiene que cumplir una versión en un peldaño para subir al siguiente.
Se escribe antes por la misma razón que los umbrales de un gate: si se elige después de ver los números, siempre se puede justificar lo que uno quería. Un buen criterio compara contra el estable en la misma ventana, dice su ventana y su n mínimo, y exige que las señales estén verdes durante todo el paso, no solo al final. Su espejo es el rollback automático.
Ejemplo. En el shadow de Alba: acuerdo top-1 ≥ 90 %, p99 ≤ 1.1 × el del champion, cero crashes y ninguna de las 20 categorías más grandes con acuerdo < 85 %. En el canary: los cuatro criterios relativos verdes durante las 4 h de cada paso.
Crop
crop
Recortar una imagen para quedarte con un pedazo. El center crop toma un cuadro del centro.
Muchos modelos de visión esperan una entrada cuadrada de tamaño fijo. Recortar del centro asume que lo importante está en medio: si el tenis estaba en una orilla, se puede quedar fuera.
Ejemplo. De 256 × 341, el center crop de 224 × 224 quita 16 píxeles de cada lado a lo ancho, y 58 arriba y 59 abajo.
CSV
comma-separated values
Un formato de texto para tablas: una fila por línea, los campos separados por comas y, casi siempre, los nombres de las columnas en la primera línea. Simple, universal y frágil.
Lo abre cualquier programa, desde Excel hasta una base de datos. Se rompe con lo que el dato comparte con el formato: una coma o un salto de línea dentro de un campo (la regla es encerrarlo entre comillas y duplicar las comillas de adentro), un separador distinto (punto y coma en los países con coma decimal) o una codificación distinta de UTF-8. Y no trae tipos: todo es texto, y quien lee adivina. Un código 007 se vuelve 7, una fecha se voltea. Nunca se parte con split(","): se lee con un lector que entienda las comillas, como el módulo csv de Python. Sirve para tablas chicas y para personas; para millones de filas, Parquet.
Ejemplo. La fila 007,"Tenis naranjas, talla 26",899.50 tiene 3 campos; partida con split(",") salen 4, y convertida a números el código queda en 7.
Cuantización
quantization
Guardar los números de un modelo con menos bits, como enteros más una escala compartida: valor ≈ escala × entero. Baja la memoria y puede acelerar, a cambio de cambiar un poco las respuestas.
En la versión simétrica, escala = máximo ÷ 127 (en INT8) y entero = redondear(valor ÷ escala); el error es, a lo mucho, media escala. La asimétrica agrega un punto cero: valor ≈ escala × (entero − punto cero). Un valor atípico agranda la escala para todo el grupo, así que se usan escalas por canal o por grupo y rangos que recortan extremos. Para las activaciones se calibra con unos cientos de ejemplos reales (calibrar aquí es medir rangos, no la calibración de probabilidades). PTQ (post-training quantization) cuantiza un modelo ya entrenado; QAT (quantization-aware training) entrena simulando el redondeo. Ningún modelo cuantizado sale sin prueba de paridad y sin medir la calidad por categoría y por slice.
Analogía. Medir con una regla: la escala es la separación entre sus rayitas. Con rayitas de un milímetro mides fino; si la regla tiene que llegar a un kilómetro con las mismas rayitas, cada una mide metros y lo chico se pierde. Se rompe en que una regla de verdad tiene las rayitas fijas; en la cuantización se eligen para cada grupo de números, según su rango.
Ejemplo. Con pesos de −2.5 a 2.5, la escala es 2.5 ÷ 127 ≈ 0.0197: el 0.1 se guarda como 5 y vuelve como 0.0984. Así, la ResNet-50 de Alba, el marketplace del curso, pasa de 98 MB a 25.1 MB.
Cuarentena de una partición
data quarantine
Apartar una partición de datos (un pedazo de la tabla, casi siempre un día) que falló sus chequeos, sin borrarla, en un lugar donde nada la lee, y avisar a su dueño.
Es mejor que borrarla, porque queda para investigar y, si el dueño la corrige, se vuelve a revisar y entra. Y es mejor que dejarla pasar, porque nadie entrena con un día roto sin saberlo. Las demás particiones siguen su camino.
Ejemplo. Si el lote de correcciones de un día llega con hora local sin zona, la revisión de entrada de Alba lo manda a cuarentena y avisa a su dueño; los otros días siguen al data lake.
CUDA
Compute Unified Device Architecture
La plataforma de NVIDIA para programar sus GPUs: un lenguaje, un compilador y bibliotecas con el trabajo ya hecho, como cuBLAS para multiplicar matrices. PyTorch la usa por debajo. Solo funciona en GPUs de NVIDIA.
Existe desde 2007. Con CUDA se escriben kernels, las funciones que corren en la GPU, y sus bibliotecas traen los más comunes ya hechos: cuBLAS multiplica matrices (viene con CUDA); cuDNN hace convoluciones, NCCL (se dice «nickel») pasa datos entre GPUs y TensorRT convierte un modelo en un engine para una GPU concreta (esas tres, NVIDIA las publica aparte). Su versión importa: el runtime de CUDA va dentro de tu imagen, y el driver de la máquina tiene que ser lo bastante nuevo para él (cualquier 12.x corre con un driver 525 o más nuevo; 13.x, con uno 580 o más). AMD tiene su propia plataforma (ROCm) y las TPUs, los chips propios de Google, otra (XLA). Ese ecosistema es buena parte de por qué casi todo el ML corre en NVIDIA. Los «CUDA cores» son carriles de cálculo, no núcleos completos.
Ejemplo. La imagen de Triton de Alba, la empresa de ejemplo del curso, tritonserver:24.08, trae CUDA 12.6, cuDNN 9.3 y TensorRT 10.3. Esas bibliotecas son la mayor parte de sus ≈ 9.2 GB.
Cuello de botella
bottleneck
El recurso que se satura primero en una cadena. Fija el throughput máximo (lo que se termina por segundo) de todo el sistema, y su fila es la que domina la latencia.
Una request pasa por varios recursos en fila (red, CPU, GPU), y el throughput de la cadena es el del más angosto. Mejorar los demás no cambia nada. Se encuentra comparando la utilización de cada recurso o, en producción, mirando qué fila crece: el histograma del preproceso, el tiempo en la fila de Triton, la red. A menudo no es la pieza más cara.
Analogía. Una cadena de tubos: el agua que sale por segundo la decide el más angosto. Se rompe en que un sistema real tiene filas antes de cada tubo, y el más angosto también es donde más se espera.
Ejemplo. Alba en el pico de diseño: la red de cada nodo del gateway va al ≈ 77 %, la CPU de cada pod al 60 % y cada T4 al ≈ 21 %. El cuello de botella es la red, no la GPU: por eso la mejora anotada es mandar el tensor en uint8.
Cuenta de la nube
cloud account
El contenedor donde viven tus recursos, tu factura y tus permisos en un proveedor. En AWS (la nube de Amazon) es una cuenta (un número de 12 dígitos); en Google Cloud, un proyecto; en Azure, una suscripción.
Todo lo que creas cae en una cuenta, y todo lo que se cobra va a su factura. Las empresas usan varias (desarrollo, producción, datos sensibles) para que un error en una no toque las otras y para separar costos. El usuario dueño, que puede hacerlo todo, se guarda bajo llave; el trabajo diario se hace con identidades de permisos acotados (IAM). Las cuotas se cuentan por cuenta y por región.
Ejemplo. El clasificador de fotos de Alba, el marketplace que sigue el curso, vive en la cuenta de producción de Alba, en us-east-1; sus pruebas, en otra cuenta, para que una máquina olvidada no se mezcle con la factura de producción.
Cuenta de servicio
service account
La identidad de un programa, no de una persona. En Kubernetes es un objeto con nombre, como classifier/triton; cada pod corre con una y recibe un token firmado que prueba quién es.
Un programa no debe usar el usuario de una persona: si ella se va, el servicio se cae, y si el programa se compromete, el atacante actúa como ella. En Google Cloud también se llaman cuentas de servicio; en AWS ese papel lo hace un rol. Con la identidad del workload, la cuenta de servicio de Kubernetes se conecta con un rol de la nube.
Ejemplo. El pod de Triton corre con la cuenta triton del namespace classifier; solo esa cuenta puede asumir el rol alba-triton.
Cuota de servicio
service quota
Un límite administrativo de cuántos recursos de un tipo puede tener tu cuenta en una región. Si te pasas, la nube te dice que no al instante; se arregla pidiendo más, con anticipación.
Cada nube cuenta distinto: AWS cuenta vCPUs por grupo de familias (una cuota para instancias G y VT on-demand, otra para P, otra para spot), Google cuenta GPUs por modelo y región más una cuota global (GPUS_ALL_REGIONS), y Azure cuenta vCPUs por familia. Se pide para el máximo (autoscaler, despliegues, staging, CI) y antes de lanzar, porque aumentarla puede tardar. Tener cuota no garantiza que haya máquinas: eso es la capacidad.
Ejemplo. Alba, el marketplace del curso: (4 del autoscaler + 1 al desplegar + 1 staging + 1 CI) × 4 vCPU = 28 vCPU de instancias G en us-east-1.
Cuota por cliente
per-caller quota
Un presupuesto de requests (o de tokens de un modelo de lenguaje) para cada identidad verificada, normalmente con un token bucket (un balde de fichas que se rellena a ritmo fijo) por cada client_id, el nombre del cliente. Quien se pasa recibe 429 él solo, sin afectar a los demás.
La identidad decide la cuota: sale del client_id del token verificado, nunca de un header que el cliente escribe ni de la IP (detrás de una red compartida hay muchos clientes, y uno solo puede usar muchas). Se implementa con un token bucket y responde 429 con Retry-After. Si el balde vive en la memoria de cada pod, cada uno da la parte que le toca (la cuota entre el número de pods), y es aproximado; uno compartido en Redis es exacto pero agrega una pieza que se puede caer. La cuota no reemplaza un tope de requests en vuelo: varios clientes dentro de su cuota pueden, juntos, saturar el servicio, y eso es un 503 (servicio no disponible).
Ejemplo. El servicio de moderación tiene 50 requests por segundo con ráfagas de 100 en el clasificador de Alba. Con el gateway en 5 pods y el balde en memoria, cada pod le da 10 por segundo y ráfagas de 20.
Curva de aprendizaje
learning curve · training curve
La gráfica de la pérdida (loss, el número que mide qué tan equivocado está el modelo) o de una métrica, en entrenamiento y en validación al final de cada época. Muestra si el modelo aprende, si memoriza o si no aprende nada.
Si las dos líneas bajan juntas, aprende. Si la de entrenamiento baja y la de validación sube, hay overfitting. Si las dos se quedan altas, underfitting. Se guarda con cada entrenamiento porque un número final solo no muestra nada de eso.
Ejemplo. Loss de validación: 2.15 en la época 1, 0.80 en la 8 (su punto más bajo) y 1.15 en la 20. El mejor checkpoint es el de la época 8.
Curva de métricas por época
per-epoch metric curve
La pérdida y la exactitud de validación anotadas al final de cada época (cada pasada completa por las fotos de entrenamiento) de una corrida. Muestra cómo se llegó al número final y distingue una corrida sana de una con overfitting o con el learning rate roto.
Un número final no dice cómo se llegó a él. La curva por época sí: en una corrida sana, la exactitud de validación sube rápido y se aplana; con overfitting, sube hasta una época y luego baja mientras la pérdida de entrenamiento sigue bajando; con el learning rate roto, la pérdida no baja de ≈ ln(número de clases), sube o da NaN. Es la curva de aprendizaje anotada en cada corrida, para ponerla junto a la del mes anterior.
Ejemplo. En Alba, val_top1 (el top-1 en validación) por época de una corrida sana va de ≈ 78.9 % a ≈ 85.4 % y se aplana (números ilustrativos). Si en otra el máximo es 84.8 % en la época 5 y termina en 82.9 %, el número final esconde su mejor época: es overfitting.
Curva PR
precision–recall curve · PR curve · average precision
La gráfica de la precision contra el recall de un modelo, para todos los umbrales posibles. Con clases muy desbalanceadas, como el fraude, dice la verdad cuando la curva ROC se ve demasiado bien.
Cada umbral es un punto: a lo ancho, el recall; a lo alto, la precision. Un modelo al azar queda en una línea horizontal a la altura de la prevalencia (la fracción de positivos), no en la diagonal. El área bajo la curva se llama average precision (AP) o PR-AUC, y su promedio entre clases es el mAP de la detección de objetos. A diferencia de la curva ROC, no usa los verdaderos negativos, así que una clase negativa gigantesca no la infla.
Ejemplo. Un detector de fraude, con 0.08 % de fraude, atrapa 70 % del fraude marcando 1 % de las compras buenas. En la ROC es el punto (1 %, 70 %), casi perfecto. En la PR es una precision de 5.3 %: de cada 100 compras marcadas, ≈ 95 son de clientes honestos.
Curva ROC
ROC curve · receiver operating characteristic
La gráfica de qué fracción de los «sí» encuentra el modelo (recall) contra qué fracción de los «no» marca por error, para todos los umbrales posibles.
Cada umbral es un punto: a lo ancho, la tasa de falsos positivos, FP / (FP + TN): los falsos positivos (FP) entre todos los negativos, que son los FP más los verdaderos negativos (TN); a lo alto, el recall. Un modelo al azar va por la diagonal; uno perfecto sube pegado a la izquierda. Como divide entre todos los negativos, con clases muy desbalanceadas se ve demasiado bien: ahí conviene la curva PR. El nombre viene de los radares de la Segunda Guerra Mundial.
Ejemplo. Con 10 fotos (4 de tenis): umbral 0.80 → 0 % de falsos positivos y 50 % de recall; 0.50 → 17 % y 75 %; 0.30 → 33 % y 100 %.
CVE
CVE (Common Vulnerabilities and Exposures)
El identificador público de un fallo de seguridad conocido, como CVE-2023-43654, con su descripción, las versiones afectadas, la que lo corrige y su gravedad.
Cada CVE trae una calificación CVSS (Common Vulnerability Scoring System) de 0 a 10; de 9.0 a 10 se llama crítica. Gracias a los CVE no tienes que leer el código de cada biblioteca: te basta saber qué versiones traes (SBOM) y cruzarlas con la lista pública (escaneo). Un fallo que nadie conoce todavía no tiene CVE, y ningún escaneo lo ve.
Ejemplo. CVE-2023-43654, el fallo principal de ShellTorch, en TorchServe (un servidor de modelos de PyTorch): su API de administración podía cargar un modelo de cualquier dirección, y eso terminaba en correr código del atacante. La NVD (la base pública de vulnerabilidades del gobierno de Estados Unidos) le dio 9.8 (crítica) y el aviso de GitHub, 10; se corrigió en la versión 0.8.2.