De PyTorch a Triton

Qué vas a provocar: Medir tú mismo los bytes de bolsillo: parámetros, MB por precisión, tamaño en disco, el tensor que viaja a Triton y los límites de FP16.

Necesitas: un venv con Python 3.13, torch 2.14.0 y torchvision 0.29.0 (las versiones del C01) e internet para instalarlos; sin GPU

1. Paso 1Copiar

   python3.13 -m venv ~/venvs/lab-triton
   source ~/venvs/lab-triton/bin/activate
   pip install torch==2.14.0 torchvision==0.29.0

   Qué deberías ver: La última línea empieza con Successfully installed e incluye torch-2.14.0 y torchvision-0.29.0, junto con sus dependencias (numpy, pillow, sympy y otras). Son las versiones del C01; no necesitas GPU.

2. Paso 2Copiar

   python -c "
   import torchvision
   m = torchvision.models.resnet50(weights=None, num_classes=500)
   P = sum(p.numel() for p in m.parameters())
   print(P, [round(P * b / 1e6, 1) for b in (4, 2, 1)])
   "

   Qué deberías ver: 24532532 [98.1, 49.1, 24.5]: los parámetros del modelo del C01 y sus MB de pesos en FP32, FP16 e INT8.

3. Paso 3Copiar

   python -c "
   import os, torch, torchvision
   m = torchvision.models.resnet50(weights=None, num_classes=500)
   torch.save(m.state_dict(), '/tmp/r50_fp32.pt'); torch.save(m.half().state_dict(), '/tmp/r50_fp16.pt')
   print([round(os.path.getsize(f) / 1e6, 1) for f in ('/tmp/r50_fp32.pt', '/tmp/r50_fp16.pt')])
   "

   Qué deberías ver: [98.4, 49.3]: un poco más que 98.1 y 49.1, porque el archivo guarda también las estadísticas del BatchNorm y los nombres de cada tensor.

4. Paso 4Copiar

   python -c "
   import json, numpy as np
   x = np.random.default_rng(0).standard_normal((1, 3, 224, 224)).astype(np.float32)
   print(x.nbytes, x.astype(np.uint8).nbytes, len(json.dumps(x.ravel().tolist())))
   "

   Qué deberías ver: 602112 150528 3105734: el tensor pesa 602 KB en FP32 y 150 KB en UINT8, pero como JSON (números en texto) son ≈ 3.1 MB, unas 5 veces más. Por eso el gateway lo manda en binario.

5. Paso 5Copiar

   python -c "import numpy as np; print(np.finfo(np.float16).max, np.spacing(np.float16(10)), np.spacing(np.float32(10)), np.float16(70000))"

   Qué deberías ver: 6.55e+04 0.007812 9.536743e-07 inf, con un aviso RuntimeWarning: overflow encountered in cast. FP16 llega hasta 65,504; cerca de 10 solo puede moverse de a 0.0078 (FP32, de a 0.00000095), y 70,000 ya no cabe: inf. Por eso un engine FP16 mueve los logits ≈ 1e-2.

6. Paso 6Copiar

   rm /tmp/r50_fp32.pt /tmp/r50_fp16.pt

   Qué deberías ver: Nada: borra los dos archivos de prueba. El venv queda para los labs de las secciones siguientes.

Probado de verdad en un Mac, sin GPU.

Qué vas a provocar: Correr en tu Mac la mitad CPU de la cadena del C01 con sus scripts reales, ver un gate que frena y ver dónde se corta sin GPU.

Necesitas: el repo del curso (apps/ml-system-design), Python 3.13 e internet para instalar model/requirements.txt; sin GPU. El engine y Triton necesitan una máquina con T4.

1. Paso 1Copiar

   cd apps/ml-system-design/reference/c01
   python3.13 -m venv .venv && source .venv/bin/activate
   pip install -r model/requirements.txt

   Qué deberías ver: Desde la raíz del repo del curso. Instala las versiones fijas del C01: torch 2.14.0, torchvision 0.29.0, onnx 1.23.0, onnxscript 0.7.2, onnxruntime 1.30.0, entre otras. Sin GPU.

2. Paso 2Copiar

   python model/export_onnx.py --out /tmp/c01.onnx

   Qué deberías ver: Primero [model] AVISO: sin --checkpoint → pesos aleatorios… y un DeprecationWarning del exportador TorchScript. Después [export] opset=17 input=input['batch', 3, 224, 224] output=logits, una línea por batch (1 y 32) con shape (1, 500) y (32, 500), max|Δlogit| del orden de 1e-5 a 1e-4 y top1_igual=100%, y al final [export] OK.

3. Paso 3Copiar

   python model/parity_check.py --onnx /tmp/c01.onnx --n 64

   Qué deberías ver: [parity] backend=ort n=64 top1_agreement=100.00% top5_overlap=100.00%, un max|Δlogit| del orden de 1e-5 a 1e-4, y [parity] PASA. Pasa porque los dos lados usan los mismos pesos aleatorios (semilla 0): prueba el pipeline, no un modelo.

4. Paso 4Copiar

   python -c "import torch, torchvision; torch.manual_seed(1); torch.save(torchvision.models.resnet50(weights=None, num_classes=500).state_dict(), '/tmp/otro.pt')"
   python model/parity_check.py --onnx /tmp/c01.onnx --checkpoint /tmp/otro.pt --n 64; echo "exit=$?"

   Qué deberías ver: top1_agreement y top5_overlap en 0 % o casi, un max|Δlogit| del orden de 100 y [parity] NO PASA: no promuevas este artefacto, con exit=1. Es lo que pasa cuando el artefacto no viene del modelo que evaluaste.

5. Paso 5Copiar

   bash model/build_engine.sh; echo "exit=$?"

   Qué deberías ver: model/build_engine.sh: line 19: nvidia-smi: command not found y exit=127 (127 = comando no encontrado). Es el borde de la cadena: desde aquí todo corre en una máquina con T4 y su driver de NVIDIA.

6. Paso 6Copiar

   deactivate
   rm /tmp/c01.onnx /tmp/otro.pt

   Qué deberías ver: Sale del venv y borra los archivos de prueba.

Verificado contra la documentación; no ejecutado aquí.

Qué vas a provocar: Medir en tu Mac los dos límites de model(x) dentro de un proceso: el batch de 1 y el event loop bloqueado.

Necesitas: el venv del lab de Números de bolsillo (Python 3.13, torch 2.14.0, torchvision 0.29.0); sin GPU

1. Paso 1Copiar

   source ~/venvs/lab-triton/bin/activate
   python - <<'EOF'
   import time, torch, torchvision
   m = torchvision.models.resnet50(weights=None, num_classes=500).eval()
   x = torch.randn(8, 3, 224, 224)
   with torch.inference_mode():
       for bs in (1, 8):
           m(x[:bs])                      # warmup de esta shape
           t = time.perf_counter()
           for _ in range(10):
               m(x[:bs])
           dt = (time.perf_counter() - t) / 10
           print(f"batch {bs:d}: {dt * 1000:.0f} ms por llamada, {bs / dt:.0f} img/s")
   EOF

   Qué deberías ver: Algo como batch 1: 13 ms por llamada, 76 img/s y batch 8: 94 ms por llamada, 85 img/s (Mac con chip Apple, 4 hilos de PyTorch). En CPU, juntar 8 imágenes casi no rinde más: no hay un acelerador que llenar. En una T4, el C01 estima ≈ 100 img/s con batch 1 y ≈ 1,200 con TensorRT y batching.

2. Paso 2Copiar

   python - <<'EOF'
   import asyncio, time, torch, torchvision
   m = torchvision.models.resnet50(weights=None, num_classes=500).eval()
   x = torch.randn(8, 3, 224, 224)
   def inferir():
       with torch.inference_mode():   # dentro de la función: el modo es por hilo
           return m(x)
   async def latido(huecos, fin):
       antes = time.perf_counter()
       while not fin.is_set():
           await asyncio.sleep(0.01)
           ahora = time.perf_counter(); huecos.append(ahora - antes); antes = ahora
   async def probar(en_hilo):
       huecos, fin = [], asyncio.Event()
       tarea = asyncio.create_task(latido(huecos, fin))
       await asyncio.sleep(0.05)
       if en_hilo:
           await asyncio.to_thread(inferir)   # como run_in_threadpool de FastAPI
       else:
           inferir()                          # CPU dentro de la corrutina: bloquea el loop
       await asyncio.sleep(0.05); fin.set(); await tarea
       print("en un hilo:" if en_hilo else "en el loop:", f"mayor hueco del latido {max(huecos) * 1000:.0f} ms")
   inferir()  # warmup
   asyncio.run(probar(False)); asyncio.run(probar(True))
   EOF

   Qué deberías ver: en el loop: mayor hueco del latido ≈ 100 ms (lo que dura la inferencia: el loop no atendió nada) y en un hilo: ≈ 10–15 ms (el latido de 10 ms siguió). Medido: 96 ms contra 12 ms. asyncio.to_thread hace lo mismo que run_in_threadpool en FastAPI.

Probado de verdad en un Mac, sin GPU.

Qué vas a provocar: Ver en números qué cambia con train(), eval(), no_grad() e inference_mode(), y cuánto ruido normal tiene FP32.

Necesitas: el venv del lab de Números de bolsillo (Python 3.13, torch 2.14.0, torchvision 0.29.0); sin GPU

1. Paso 1Copiar

   source ~/venvs/lab-triton/bin/activate
   python - <<'EOF'
   import torch, torchvision
   torch.manual_seed(0)
   m = torchvision.models.resnet50(weights=None, num_classes=500)
   x = torch.randn(8, 3, 224, 224)
   m.eval()
   with torch.inference_mode():
       ref = m(x)
   m.train()
   with torch.no_grad():
       tr = m(x)
   print("max|Δ| train vs eval:", round((tr - ref).abs().max().item(), 1))
   print("top-1 igual:", (tr.argmax(1) == ref.argmax(1)).float().mean().item())
   EOF

   Qué deberías ver: max|Δ| train vs eval: 83.4 y top-1 igual: 0.0. Con pesos aleatorios, las running stats todavía valen 0 y 1, así que la diferencia es enorme; con un modelo entrenado es menor, pero existe.

2. Paso 2Copiar

   python - <<'EOF'
   import torch, torchvision
   torch.manual_seed(0)
   m = torchvision.models.resnet50(weights=None, num_classes=500).train()
   antes = m.bn1.running_mean.clone()
   with torch.no_grad():
       m(torch.randn(8, 3, 224, 224))
   print("running_mean cambió:", not torch.equal(antes, m.bn1.running_mean), "| batches vistos:", m.bn1.num_batches_tracked.item())
   EOF

   Qué deberías ver: running_mean cambió: True | batches vistos: 1. Un solo forward en train(), sin gradientes, ya modificó el modelo.

3. Paso 3Copiar

   python - <<'EOF'
   import torch, torchvision
   m = torchvision.models.resnet50(weights=None, num_classes=500).eval()
   x = torch.randn(1, 3, 224, 224)
   y0 = m(x)
   with torch.no_grad():
       y1 = m(x)
   with torch.inference_mode():
       y2 = m(x)
   print(y0.requires_grad, y1.requires_grad, y2.requires_grad, y2.is_inference())
   try:
       (y2 * torch.ones(500, requires_grad=True)).sum().backward()
   except RuntimeError as e:
       print(str(e).split(".")[0])
   EOF

   Qué deberías ver: True False False True: sin nada, la salida arrastra el grafo para el backward; con no_grad e inference_mode, no. Después: Inference tensors cannot be saved for backward. Un tensor creado en inference_mode no puede entrar a autograd.

4. Paso 4Copiar

   python - <<'EOF'
   import threading, torch
   with torch.inference_mode():
       t = threading.Thread(target=lambda: print("hilo nuevo:", torch.is_inference_mode_enabled()))
       t.start(); t.join()
       print("hilo actual:", torch.is_inference_mode_enabled())
   EOF

   Qué deberías ver: hilo nuevo: False y hilo actual: True. El modo vale por hilo: en FastAPI, el with va dentro de la función que corre en el threadpool.

5. Paso 5Copiar

   python - <<'EOF'
   import torch, torchvision
   torch.manual_seed(0)
   m = torchvision.models.resnet50(weights=None, num_classes=500).eval()
   x = torch.randn(8, 3, 224, 224)
   with torch.inference_mode():
       juntos = m(x)
       de_a_uno = torch.cat([m(x[i:i + 1]) for i in range(8)])
   print(f"max|Δ| batch 8 vs batch 1: {(juntos - de_a_uno).abs().max().item():.1e} | max|logit|: {de_a_uno.abs().max().item():.0f}")
   EOF

   Qué deberías ver: max|Δ| batch 8 vs batch 1: 1.5e-04 | max|logit|: 85. Las mismas imágenes en otro batch cambian el orden de las sumas: ese ≈ 1e-4 es el ruido normal de FP32, el que verás también entre PyTorch y ONNX Runtime.

Probado de verdad en un Mac, sin GPU.

Qué vas a provocar: Exportar un ResNet-18 a ONNX a mano, revisarlo, correrlo en ONNX Runtime con dos tamaños de batch y provocar los dos errores más comunes.

Necesitas: el venv de los labs anteriores (torch 2.14.0 y torchvision 0.29.0) más onnx 1.23.0 y onnxruntime 1.30.0, las versiones del C01; sin GPU

1. Paso 1Copiar

   source ~/venvs/lab-triton/bin/activate
   pip install onnx==1.23.0 onnxruntime==1.30.0
   mkdir -p ~/lab-onnx && cd ~/lab-onnx

   Qué deberías ver: Instala las versiones del C01 en el venv de los labs anteriores, que ya tiene torch 2.14.0 y torchvision 0.29.0.

2. Paso 2Copiar

   python - <<'EOF'
   import torch, torchvision
   torch.manual_seed(0)
   m = torchvision.models.resnet18(weights=None, num_classes=500).eval()
   torch.onnx.export(m, (torch.randn(2, 3, 224, 224),), "r18.onnx", dynamo=False, opset_version=17,
                     input_names=["input"], output_names=["logits"],
                     dynamic_axes={"input": {0: "batch"}, "logits": {0: "batch"}})
   EOF
   ls -lh r18.onnx

   Qué deberías ver: Un DeprecationWarning que empieza con You are using the legacy TorchScript-based ONNX export (es el exportador viejo, pedido a propósito) y un archivo de 44M: 11.4 M parámetros × 4 B ≈ 45.7 MB, que ls -h muestra en MiB.

3. Paso 3Copiar

   python - <<'EOF'
   import onnx
   p = onnx.load("r18.onnx")
   onnx.checker.check_model(p, full_check=True)
   print("opset", [o.version for o in p.opset_import if o.domain in ("", "ai.onnx")])
   print(p.graph.input[0].name, [d.dim_param or d.dim_value for d in p.graph.input[0].type.tensor_type.shape.dim])
   print(sorted({n.op_type for n in p.graph.node}))
   EOF

   Qué deberías ver: opset [17], input ['batch', 3, 224, 224] y los tipos de nodo ['Add', 'Conv', 'Flatten', 'Gemm', 'GlobalAveragePool', 'Identity', 'MaxPool', 'Relu']. No hay BatchNormalization: quedó plegado en cada Conv. Los Identity salen solo con pesos aleatorios (bias plegados iguales que el exportador comparte).

4. Paso 4Copiar

   python - <<'EOF'
   import numpy as np, onnxruntime as ort, torch, torchvision
   torch.manual_seed(0)
   m = torchvision.models.resnet18(weights=None, num_classes=500).eval()
   s = ort.InferenceSession("r18.onnx", providers=["CPUExecutionProvider"])
   for bs in (1, 7):
       x = torch.randn(bs, 3, 224, 224)
       with torch.inference_mode():
           ref = m(x).numpy()
       got = s.run(["logits"], {"input": x.numpy()})[0]
       print(bs, got.shape, f"max|Δ| {np.abs(ref - got).max():.1e}")
   EOF

   Qué deberías ver: 1 (1, 500) y 7 (7, 500), cada una con un max|Δ| chico, entre 1e-6 y 1e-4: el ruido normal de FP32. El eje dinámico funciona: el batch 7 nunca se vio en el export.

5. Paso 5Copiar

   python - <<'EOF'
   import onnxruntime as ort, torch, torchvision
   torch.manual_seed(0)
   m = torchvision.models.resnet18(weights=None, num_classes=500).eval()
   torch.onnx.export(m, (torch.randn(2, 3, 224, 224),), "r18_fijo.onnx", dynamo=False, opset_version=17,
                     input_names=["input"], output_names=["logits"])
   s = ort.InferenceSession("r18_fijo.onnx", providers=["CPUExecutionProvider"])
   print(s.get_inputs()[0].shape)
   s.run(["logits"], {"input": torch.randn(7, 3, 224, 224).numpy()})
   EOF

   Qué deberías ver: [2, 3, 224, 224]: sin dynamic_axes, el batch quedó fijo en el del ejemplo. Después, un error de tres líneas (cada / es un salto de línea): [ONNXRuntimeError] : 2 : INVALID_ARGUMENT : Got invalid dimensions for input: input for the following indices / index: 0 Got: 7 Expected: 2 / Please fix either the inputs/outputs or the model.

6. Paso 6Copiar

   python -c "
   import numpy as np, onnxruntime as ort
   s = ort.InferenceSession('r18.onnx', providers=['CPUExecutionProvider'])
   s.run(['logits'], {'input': np.random.rand(1, 3, 224, 224)})
   "

   Qué deberías ver: INVALID_ARGUMENT : Unexpected input data type. Actual: (tensor(double)) , expected: (tensor(float)). numpy crea float64 por defecto y el modelo pide float32: se arregla con .astype(np.float32).

7. Paso 7Copiar

   cd ~ && rm -r ~/lab-onnx

   Qué deberías ver: Borra los archivos del lab.

Verificado contra la documentación; no ejecutado aquí.

Qué vas a provocar: Ver la escala de |Δlogit| que separa el ruido, FP16 y un bug, y por qué el gate necesita el modelo entrenado.

Necesitas: el venv del lab de Números de bolsillo (torch 2.14.0 y torchvision 0.29.0); sin GPU. La paridad real con parity_check.py necesita además onnxruntime y el checkpoint.

1. Paso 1Copiar

   source ~/venvs/lab-triton/bin/activate
   python - <<'EOF'
   import copy, numpy as np, torch, torchvision
   torch.manual_seed(0)
   m = torchvision.models.resnet50(weights=None, num_classes=500).eval()
   x = torch.randn(16, 3, 224, 224)
   def delta(nombre, got):
       d = np.abs(ref - got.float().numpy())
       print(f"{nombre:<24} max|Δ| {d.max():.1e} · media|Δ| {d.mean():.1e}")
   with torch.inference_mode():
       ref = m(x).numpy()
       delta("FP32, de a una imagen", torch.cat([m(x[i:i + 1]) for i in range(16)]))
       delta("FP16 (pesos y cálculo)", copy.deepcopy(m).half()(x.half()))
       delta("BGR en vez de RGB", m(x.flip(1)))
   EOF

   Qué deberías ver: Tres líneas, una por caso: FP32, de a una imagen → max|Δ| 1.7e-04 · media|Δ| 1.9e-05; FP16 (pesos y cálculo) → max|Δ| 6.6e-02 · media|Δ| 1.3e-02; BGR en vez de RGB → max|Δ| 1.7e+00 · media|Δ| 3.3e-01. Tres escalas: aritmética, redondeo de FP16 y un error de preprocesamiento. El tope del gate (0.5) queda entre las dos últimas. Tarda unos segundos: FP16 en CPU es lento.

2. Paso 2Copiar

   python - <<'EOF'
   import numpy as np, torch, torchvision
   torch.manual_seed(0)
   m = torchvision.models.resnet50(weights=None, num_classes=500).eval()
   with torch.inference_mode():
       z = np.sort(m(torch.randn(64, 3, 224, 224)).numpy(), 1)
   margen = z[:, -1] - z[:, -2]
   print(f"1.º menos 2.º logit: mediana {np.median(margen):.2f}, mínimo {margen.min():.3f}")
   EOF

   Qué deberías ver: 1.º menos 2.º logit: mediana 0.49, mínimo 0.001. Con pesos aleatorios hay imágenes donde el 1.º y el 2.º lugar están a milésimas, y cualquier redondeo cambia el top-1. Por eso el gate de verdad corre con --checkpoint e imágenes reales, donde casi todas las imágenes tienen márgenes amplios.

3. Paso 3Copiar

   python -c "print([int((1 - 0.995) * n) for n in (256, 2000)])"

   Qué deberías ver: [1, 10]: con el default --n 256, el gate tolera un solo cambio de top-1; con 2,000 imágenes, diez.

Probado de verdad en un Mac, sin GPU.

Qué vas a provocar: Armar el repository de C01 en tu Mac y validar su config.pbtxt contra el mensaje ModelConfig real de Triton (sin GPU), para ver qué errores atrapa el parser y cuáles no.

Necesitas: Python 3.13, como en los demás labs (como mínimo 3.10: tritonclient[grpc] 2.73 pide grpcio 1.81.1 o más nuevo, que ya no tiene versión para Python 3.9). Internet para pip (tritonclient, grpcio y protobuf). No necesitas GPU ni Docker.

1. Paso 1Copiar

   mkdir -p ~/lab-repositorio && cd ~/lab-repositorio
   python3.13 -m venv .venv && . .venv/bin/activate
   pip install "tritonclient[grpc]==2.73.0"
   mkdir -p model_repository/classifier/1

   Qué deberías ver: pip termina con Successfully installed y, en la lista, tritonclient-2.73.0, grpcio y protobuf (una 6.x: tritonclient 2.73 pide protobuf menor que 7). tritonclient es Python puro y grpcio trae wheels para macOS: se instala igual en un Mac con Apple Silicon.

2. Paso 2Copiar

   cat > model_repository/classifier/config.pbtxt <<'EOF'
   name: "classifier"
   platform: "tensorrt_plan"
   max_batch_size: 32
   version_policy: { latest: { num_versions: 1 } }
   input [ { name: "input", data_type: TYPE_FP32, dims: [ 3, 224, 224 ] } ]
   output [ { name: "logits", data_type: TYPE_FP32, dims: [ 500 ] } ]
   dynamic_batching {
     max_queue_delay_microseconds: 2000
     default_queue_policy { timeout_action: REJECT, default_timeout_microseconds: 100000 }
   }
   instance_group [ { count: 2, kind: KIND_GPU } ]
   model_warmup [ { name: "warmup_max_batch", batch_size: 32, count: 3,
     inputs { key: "input", value: { data_type: TYPE_FP32, dims: [ 3, 224, 224 ], zero_data: true } } } ]
   EOF
   find model_repository

   Qué deberías ver: find lista model_repository, model_repository/classifier, la carpeta 1 y el config.pbtxt. La carpeta 1 queda vacía: el engine solo se construye en una T4.

3. Paso 3Copiar

   cat > valida.py <<'EOF'
   import sys
   from google.protobuf import text_format
   from tritonclient.grpc import model_config_pb2 as mc
   
   cfg = text_format.Parse(open(sys.argv[1]).read(), mc.ModelConfig())
   print(cfg.name, cfg.platform, cfg.max_batch_size, list(cfg.input[0].dims), cfg.instance_group[0].count)
   EOF
   python valida.py model_repository/classifier/config.pbtxt

   Qué deberías ver: classifier tensorrt_plan 32 [3, 224, 224] 2. El archivo es protobuf válido para ModelConfig: los mismos nombres de campo y de enum que lee Triton.

4. Paso 4Copiar

   sed -i.bak 's/name: "input", data_type: TYPE_FP32/name: "input", data_type: FP32/' model_repository/classifier/config.pbtxt
   python valida.py model_repository/classifier/config.pbtxt

   Qué deberías ver: Falla con google.protobuf.text_format.ParseError: la línea 5 y el texto Enum type "inference.DataType" has no value named FP32. FP32 es el nombre del protocolo (el de tritonclient), no el del config.

5. Paso 5Copiar

   mv model_repository/classifier/config.pbtxt.bak model_repository/classifier/config.pbtxt
   sed -i.bak 's/max_batch_size/max_batch_sise/' model_repository/classifier/config.pbtxt
   python valida.py model_repository/classifier/config.pbtxt

   Qué deberías ver: Otro ParseError: Message type "inference.ModelConfig" has no field named "max_batch_sise". Un campo mal escrito también impide la carga.

6. Paso 6Copiar

   mv model_repository/classifier/config.pbtxt.bak model_repository/classifier/config.pbtxt
   sed -i.bak 's/kind: KIND_GPU/kind: KIND_CPU/' model_repository/classifier/config.pbtxt
   python valida.py model_repository/classifier/config.pbtxt
   cat model_repository/classifier/config.pbtxt

   Qué deberías ver: valida.py imprime lo mismo que en el paso 3: el protobuf es válido. Pero pega el config en el revisor de esta página: marca tensorrt-en-cpu. Triton tampoco lo cargaría (TensorRT backend supports only GPU device). El parser revisa nombres; el sentido lo revisan el revisor y Triton.

7. Paso 7Copiar

   deactivate && cd ~ && rm -r ~/lab-repositorio

   Qué deberías ver: Sin salida: borraste el venv y el repository de prueba.

Verificado contra la documentación; no ejecutado aquí. Verificado: tritonclient 2.73.0 es un wheel py3-none-any y su extra [grpc] pide grpcio ≥ 1.81.1 (wheels solo para Python ≥ 3.10) y protobuf ≥ 6.30 y < 7; tritonclient.grpc importa model_config_pb2 y, sin grpc, lanza The installation does not include grpc support; el paquete del proto es inference; los textos de los ParseError salen de text_format.py de protobuf (iguales en la 6.33 y en la 7.36, donde se probaron sobre un mensaje incluido en protobuf); las tres ediciones con sed (BSD) se probaron sobre el archivo; el config es el de M07, que el curso parseó contra el ModelConfig de tritonclient 2.72.

Qué vas a provocar: Ver cómo cambian el batch y la espera con la tasa de llegada y con la ventana, en una simulación en Python de la regla del dynamic batcher con los números de C01. No corre Triton: imita su regla.

Necesitas: Python 3.9 o más nuevo, sin paquetes extra. Ni GPU ni Docker.

1. Paso 1Copiar

   mkdir -p ~/lab-batching && cd ~/lab-batching
   cat > batcher.py <<'EOF'
   # batcher.py: la regla del dynamic batcher de Triton en pocas líneas (simulación, no es Triton)
   import math, random, sys
   
   def simular(tasa, ventana_ms, max_batch=32, n=50000):
       random.seed(1)  # misma semilla = mismos números en cualquier Python 3
       t, llegadas = 0.0, []
       for _ in range(n):  # llegadas al azar (Poisson): `tasa` requests por segundo
           t += -math.log(1.0 - random.random()) / tasa * 1000.0
           llegadas.append(t)
       gpu_libre, i, lotes, esperas, totales = 0.0, 0, [], [], []
       while i < n:
           corte = max(llegadas[i] + ventana_ms, gpu_libre)  # el primero espera compañía hasta aquí
           j = i
           while j < n and j - i < max_batch and llegadas[j] <= corte:
               j += 1  # suben al bus los que llegaron antes del corte
           sale = max(llegadas[j - 1], gpu_libre) if j - i == max_batch else corte  # lleno: sale ya
           computo = 3.25 + 0.74 * (j - i)  # ms en la GPU, ilustrativo (≈ tabla de M03)
           gpu_libre = sale + computo
           lotes.append(j - i)
           esperas += [sale - x for x in llegadas[i:j]]
           totales += [sale + computo - x for x in llegadas[i:j]]
           i = j
       totales.sort()
       return sum(lotes) / len(lotes), sum(esperas) / len(esperas), totales[int(0.99 * n)]
   
   tasa = float(sys.argv[1]) if len(sys.argv) > 1 else 250
   for ventana in (0, 2, 10):
       b, espera, p99 = simular(tasa, ventana)
       print(f"{tasa:.0f} req/s  ventana {ventana} ms  batch medio {b:.1f}  espera media {espera:.1f} ms  p99 {p99:.1f} ms")
   EOF
   python3 batcher.py 250

   Qué deberías ver: Tres líneas, una por ventana: 250 req/s ventana 0 ms batch medio 1.4 espera media 1.7 ms p99 10.8 ms; con 2 ms: batch 1.7, espera 2.2 ms, p99 10.8 ms; con 10 ms: batch 3.5, espera 6.4 ms, p99 18.4 ms. La ventana de 2 ms casi no cambia el p99. La de 10 ms duplica el batch, pero sube el p99 de 10.8 a 18.4 ms: a esta carga, la GPU no necesita batches más grandes.

2. Paso 2Copiar

   python3 batcher.py 500

   Qué deberías ver: El failover de C01 (toda la carga en una GPU): batch medio 2.7 con ventana 0 y 2.9 con 2 ms; p99 15.3 ms. El batch sube solo con el tráfico, dentro del ≈ 2–4 que estima C01.

3. Paso 3Copiar

   python3 batcher.py 1000

   Qué deberías ver: Batch medio 12.2 aunque la ventana sea 0 ms: con carga, los requests se acumulan mientras la GPU trabaja y el batcher se los lleva juntos. p99 ≈ 40 ms.

4. Paso 4Copiar

   python3 batcher.py 1200

   Qué deberías ver: Espera media ≈ 164 ms y p99 ≈ 285 ms con cualquier ventana: pasaste el codo (con estos tiempos, la GPU da ≈ 1,190 img/s con batch 32). La cola crece mientras dure la carga; en C01, la política de la cola rechazaría a los 100 ms.

5. Paso 5Copiar

   cd ~ && rm -r ~/lab-batching

   Qué deberías ver: Sin salida.

Probado de verdad en macOS (Apple Silicon), sin GPU, con Python 3.9.6 y 3.14.3. Salida idéntica, con las cifras de arriba. Simula la regla documentada del dynamic batcher (sale lleno o al vencer la espera, cuando la GPU queda libre) con tiempos de cómputo ilustrativos de M03.

Qué vas a provocar: Ver sin servidor qué viaja en un request KServe v2: el tensor de C01 en binario y en JSON, y el header que arma tritonclient.

Necesitas: Python 3.13, como en los demás labs, e internet para pip (tritonclient y numpy). No necesitas GPU, Docker ni Triton.

1. Paso 1Copiar

   mkdir -p ~/lab-cliente && cd ~/lab-cliente
   python3.13 -m venv .venv && . .venv/bin/activate
   pip install "tritonclient[http]==2.73.0" numpy

   Qué deberías ver: Successfully installed y, en la lista, tritonclient-2.73.0 y numpy. No hace falta Triton: el body del request se arma en tu máquina.

2. Paso 2Copiar

   cat > cuerpo.py <<'EOF'
   import numpy as np
   import tritonclient.http as httpclient
   
   x = np.random.default_rng(0).standard_normal((1, 3, 224, 224), dtype=np.float32)  # como el tensor del gateway
   for binario in (True, False):
       inp = httpclient.InferInput("input", list(x.shape), "FP32")
       inp.set_data_from_numpy(x, binary_data=binario)
       out = httpclient.InferRequestedOutput("logits", binary_data=binario)
       body, header = httpclient.InferenceServerClient.generate_request_body([inp], outputs=[out])
       print("binario" if binario else "JSON", len(body), "bytes; header JSON:", header)
   EOF
   python cuerpo.py

   Qué deberías ver: Dos líneas. Binario: el body mide el header (≈ 175 bytes) más los 602,112 bytes del tensor. JSON: ≈ 3,000,000 bytes y header None, porque todo el body es JSON: unas 5 veces más.

3. Paso 3Copiar

   python - <<'EOF'
   import numpy as np
   import tritonclient.http as httpclient
   
   inp = httpclient.InferInput("input", [1, 3, 224, 224], "FP32")
   inp.set_data_from_numpy(np.zeros((1, 3, 224, 224), dtype=np.float32))
   body, header = httpclient.InferenceServerClient.generate_request_body([inp])
   print(body[:header].decode())
   EOF

   Qué deberías ver: El header JSON: inputs con name input, shape [1,3,224,224], datatype FP32 y parameters con binary_data_size 602112. Como no pediste salidas, el cliente agrega binary_data_output: true para recibirlas todas en binario.

4. Paso 4Copiar

   python - <<'EOF'
   import numpy as np
   import tritonclient.http as httpclient
   
   inp = httpclient.InferInput("input", [1, 3, 224, 224], "FP32")
   inp.set_data_from_numpy(np.zeros((1, 224, 224, 3), dtype=np.float32))
   EOF

   Qué deberías ver: InferenceServerException: got unexpected numpy array shape [1, 224, 224, 3], expected [1, 3, 224, 224]. El cliente revisa la shape (y el dtype) antes de mandar nada: una imagen en HWC no llega a Triton.

5. Paso 5Copiar

   deactivate && cd ~ && rm -r ~/lab-cliente

   Qué deberías ver: Sin salida.

Verificado contra la documentación; no ejecutado aquí. Verificado en el código de tritonclient: generate_request_body es estático y devuelve el body y el tamaño del header (None si todo es JSON); el JSON se arma con rapidjson, sin espacios; sin outputs agrega binary_data_output; el error de shape usa got unexpected numpy array shape. Los tamaños se calcularon aparte con la misma estructura y los mismos floats: header de 174 bytes y body JSON de ≈ 2.95 MB (≈ 19.6 B por número; M07 midió 20.6 con json.dumps, que agrega un espacio tras cada coma).

Qué vas a provocar: Comparar el preproceso de C01 contra el de torchvision y contra cuatro versiones «casi iguales», y ver que el skew cambia la entrada y la salida del modelo sin lanzar un solo error.

Necesitas: Tu Mac (CPU) y el venv de model/requirements.txt de C01 (Python 3.13); los pasos se corren desde la raíz del repo. El ResNet-50 usa pesos al azar: no descarga pesos.

1. Paso 1Copiar

   cd apps/ml-system-design/reference/c01 && python3.13 -m venv .venv && . .venv/bin/activate && pip install -r model/requirements.txt

   Qué deberías ver: Termina con Successfully installed … (torch 2.14.0, torchvision 0.29.0, pillow 12.3.0, numpy 2.5.3, onnx, onnxruntime, entre otras). Es el entorno del job de export y paridad de C01; sirve también para los labs de optimizar y de errores.

2. Paso 2Copiar

   mkdir -p ~/lab-triton && cat > ~/lab-triton/skew_lab.py <<'EOF'
   import io, sys
   import numpy as np, torch, torch.nn.functional as F, torchvision
   from PIL import Image
   from torchvision import transforms as T
   sys.path.insert(0, sys.argv[1])                      # la carpeta gateway/ de C01
   from app.preprocess import preprocess, MEAN, STD    # el preproceso real de C01
   
   tv = T.Compose([T.Resize(256), T.CenterCrop(224), T.ToTensor(),
                   T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])   # el del notebook
   rgb = lambda b: Image.open(io.BytesIO(b)).convert("RGB")
   def chw(a): return ((np.asarray(a, np.float32) / 255).transpose(2, 0, 1) - MEAN) / STD
   def interp(b):                                       # resize a mano con F.interpolate (antialias=False)
       x = torch.from_numpy(np.asarray(rgb(b), np.float32) / 255).permute(2, 0, 1)
       h, w = x.shape[1:]; nh, nw = (int(256 * h / w), 256) if w <= h else (256, int(256 * w / h))
       x = F.interpolate(x[None], size=(nh, nw), mode="bilinear")[0]
       t, l = int(round((nh - 224) / 2)), int(round((nw - 224) / 2))
       return (x[:, t:t + 224, l:l + 224].numpy() - MEAN) / STD
   variantes = {"preprocess.py de C01": preprocess,
                "BGR en vez de RGB": lambda b: preprocess(b)[::-1].copy(),
                "Resize((224, 224)) directo": lambda b: chw(rgb(b).resize((224, 224), Image.Resampling.BILINEAR)),
                "F.interpolate sin antialias": interp,
                "sin Normalize": lambda b: preprocess(b) * STD + MEAN}
   
   def foto(h, w, rng):                                 # JPEG sintético, como parity_check.py
       y, x = np.mgrid[0:h, 0:w]
       img = np.stack([x / w, y / h, (x + y) / (w + h)], -1) * 255 * rng.random(3) + rng.normal(0, 25, (h, w, 3))
       buf = io.BytesIO(); Image.fromarray(np.clip(img, 0, 255).astype(np.uint8)).save(buf, "JPEG", quality=90)
       return buf.getvalue()
   
   rng = np.random.default_rng(0)
   fotos = [foto(*rng.integers(300, 1025, size=2), rng) for _ in range(32)]   # lado corto ≤ 1024: sin draft
   torch.manual_seed(0)
   model = torchvision.models.resnet50(weights=None, num_classes=500).eval()   # pesos al azar: sin descargas
   ref = np.stack([tv(rgb(b)).numpy() for b in fotos])
   with torch.inference_mode():
       ref_logits = model(torch.from_numpy(ref)).numpy()
   print(f"{'32 fotos de hasta 1024 px':<28}{'max|Δx|':>9}{'media|Δx|':>11}{'max|Δlogit|':>13}")
   for nombre, f in variantes.items():
       x = np.stack([f(b) for b in fotos]).astype(np.float32)
       with torch.inference_mode():
           d = np.abs(model(torch.from_numpy(x)).numpy() - ref_logits).max()
       print(f"{nombre:<28}{np.abs(x - ref).max():>9.3f}{np.abs(x - ref).mean():>11.4f}{d:>13.3f}")
   g = foto(3000, 4000, rng)                            # 12 MP: preprocess.py activa el draft mode
   dx = np.abs(preprocess(g) - tv(rgb(g)).numpy())
   print(f"foto de 12 MP con draft mode: max|Δx| {dx.max():.3f} · media|Δx| {dx.mean():.4f}")
   EOF

   Qué deberías ver: Sin salida: el script queda en ~/lab-triton/skew_lab.py. Genera 32 JPEG sintéticos de hasta 1024 px y uno de 12 MP; no descarga nada.

3. Paso 3Copiar

   python ~/lab-triton/skew_lab.py gateway

   Qué deberías ver: Una tabla. preprocess.py de C01: 0.000 · 0.0000 · 0.000 (idéntico a torchvision). BGR en vez de RGB: ≈ 3.553 · 0.5914 · 12.956. Resize((224, 224)) directo: ≈ 1.882 · 0.1803 · 8.630. F.interpolate sin antialias: ≈ 1.060 · 0.0871 · 6.675. sin Normalize: ≈ 2.118 · 1.1401 · 49.126. Y la foto de 12 MP con draft mode: max|Δx| ≈ 0.035 · media ≈ 0.0055. Ninguna variante lanza un error. Tarda ≈ 15 s en una Mac M4.

4. Paso 4Copiar

   python -c "import torch, torchvision; torchvision.models.resnet50(num_classes=500).eval()(torch.zeros(1, 224, 224, 3))"

   Qué deberías ver: RuntimeError: Given groups=1, weight of size [64, 3, 7, 7], expected input[1, 224, 224, 3] to have 3 channels, but got 224 channels instead. El layout HWC sí falla con un error; los cuatro skews de la tabla, no.

Probado de verdad en un Mac, sin GPU.

Qué vas a provocar: Exportar el ResNet-50 de C01, cuantizarlo a INT8 con ONNX Runtime y medir ms por imagen en CPU, FP32 contra INT8, para convertirlo en vCPU con la fórmula.

Necesitas: Tu Mac (CPU), Python 3.13 y el venv de model/requirements.txt de C01 (torch 2.14, onnx 1.23, onnxscript 0.7.2, onnxruntime 1.30): unos 2 GB de disco; los pasos se corren desde la raíz del repo. Pesos al azar: mide velocidad y tamaño, no calidad.

1. Paso 1Copiar

   cd apps/ml-system-design/reference/c01 && . .venv/bin/activate

   Qué deberías ver: Queda activo el venv de C01, el del lab de pre y postprocesamiento. Si no lo hiciste: python3.13 -m venv .venv && . .venv/bin/activate && pip install -r model/requirements.txt.

2. Paso 2Copiar

   python model/export_onnx.py --out model/classifier.onnx

   Qué deberías ver: [model] AVISO: sin --checkpoint → pesos aleatorios…, [export] opset=17 input=input['batch', 3, 224, 224] output=logits, dos líneas de verificación (batch= 1 y batch=32, max|Δlogit| del orden de 1e-4, top1_igual=100%) y [export] OK. El archivo pesa ≈ 98 MB.

3. Paso 3Copiar

   mkdir -p ~/lab-triton && cat > ~/lab-triton/cuantizar.py <<'EOF'
   import sys
   sys.path.insert(0, "model")
   from onnxruntime.quantization import (CalibrationDataReader, CalibrationMethod, QuantFormat,
                                         QuantType, quantize_static)
   from onnxruntime.quantization.shape_inference import quant_pre_process
   from parity_check import load_images  # JPEG sintéticos pasados por el preprocess.py de C01
   
   class Lector(CalibrationDataReader):
       def __init__(self):
           self.fotos = iter(load_images(None, 64))  # para practicar; en serio: ≈ 500–1,000 fotos reales
       def get_next(self):
           x = next(self.fotos, None)
           return None if x is None else {"input": x[None]}  # [1, 3, 224, 224] float32
   
   quant_pre_process("model/classifier.onnx", "model/classifier_pre.onnx")
   quantize_static("model/classifier_pre.onnx", "model/classifier_int8.onnx", Lector(),
                   quant_format=QuantFormat.QDQ, activation_type=QuantType.QInt8,
                   weight_type=QuantType.QInt8, per_channel=True,
                   calibrate_method=CalibrationMethod.Percentile)
   EOF
   python ~/lab-triton/cuantizar.py && ls -lh model/classifier.onnx model/classifier_int8.onnx

   Qué deberías ver: Puede imprimir advertencias de ONNX Runtime durante la calibración. ls -lh cuenta en MiB: ≈ 94M para classifier.onnx (≈ 98 MB) y ≈ 24M para classifier_int8.onnx (≈ 25 MB; 25.1 MB en la medición del curso): 4× menos bytes.

4. Paso 4Copiar

   cat > ~/lab-triton/bench.py <<'EOF'
   import time
   import numpy as np
   import onnxruntime as ort
   
   x = np.random.default_rng(0).standard_normal((1, 3, 224, 224), dtype=np.float32)
   for f in ("model/classifier.onnx", "model/classifier_int8.onnx"):
       for hilos in (1, 4):
           o = ort.SessionOptions()
           o.intra_op_num_threads, o.inter_op_num_threads = hilos, 1
           s = ort.InferenceSession(f, o, providers=["CPUExecutionProvider"])
           for _ in range(10):
               s.run(["logits"], {"input": x})  # warmup
           t0 = time.perf_counter()
           for _ in range(100):
               s.run(["logits"], {"input": x})
           ms = (time.perf_counter() - t0) * 10  # 100 corridas → ms por imagen
           vcpu = 500 * ms * hilos / 1000 / 0.6  # CPU por imagen = hilos × ms; HPA al 60 %
           print(f"{f:<28} {hilos} hilo(s): {ms:5.1f} ms/img · vCPU a 500 req/s: {vcpu:5.1f}")
   EOF
   python ~/lab-triton/bench.py

   Qué deberías ver: Cuatro líneas. En la Mac M4 del curso (ORT 1.30): FP32 ≈ 20 ms con 1 hilo y ≈ 15–18 ms con 4; INT8 ≈ 21 ms con 1 hilo y ≈ 8 ms con 4. Con 1 hilo, INT8 no gana: ahí el FP32 usa la unidad de matrices de la M4 (SME) y el INT8 no. La columna vCPU es la fórmula de arriba con la CPU por imagen (hilos × ms).