Token LabBuscar

AI SYSTEMS · INFERENCE

IA que acelera la inferencia de IA: del kernel al servicio fiable

Un estudio de mecanismos, evidencia reciente, límites físicos, arquitectura productiva y práctica local reproducible.

GPU kernelsAI agentsInferenceRSI

Fuentes y versiones
En este artículo

¿Qué mejora realmente?

La optimización asistida por IA utiliza un modelo para proponer cambios al código o la configuración que ejecuta otro modelo, y evidencia externa para seleccionarlos. Los pesos pueden permanecer fijos; el optimizador puede ser otro modelo en otro equipo.

Distingue implementación de operaciones, configuración del servicio y cambios de precisión o decodificación. Usar «el mismo modelo» no garantiza equivalencia si cambian muestreo, precisión o longitud de salida.

Seguiremos un asistente SRE que convierte evidencia de incidentes en informes: del pedido a la GPU y de la propuesta a un despliegue controlado. Es un diseño de referencia propio, no la arquitectura interna de un proveedor.

Bases: tensores, memoria y latencia

Un tensor incluye forma, tipo y strides: estos últimos indican dónde están sus elementos. Un kernel para datos contiguos puede fallar con una vista transpuesta. La suma flotante no es asociativa; cambiar reducciones modifica errores numéricos.

HBM ofrece capacidad; registros y memoria compartida ofrecen proximidad. Fusionar operaciones reduce escrituras intermedias y lanzamientos, pero aumenta valores vivos y puede reducir ocupación. Los bloques reutilizan datos, sin garantizar mejoras universales.

Latencia mide una solicitud; throughput mide trabajo total por segundo. Cerca de saturación, las colas pueden dominar. Primero fija contratos de tensores y plazos del producto.

Una solicitud: prefill y decode

La API autentica, tokeniza y encola. El planificador admite según capacidad; prefill procesa el prompt y crea KV; decode calcula y muestrea sucesivos tokens y amplía el estado. Cancelar debe liberar recursos.

Prefill suele aprovechar matrices grandes. Decode con lotes pequeños suele mover muchos pesos y KV por operación. Lotes mayores reutilizan pesos, pero contexto largo, modelos dispersos e interconexión cambian el cuello de botella.

TTFT incluye red y cola hasta el primer token. El intervalo entre tokens se mide en el flujo, no en un kernel. Publica percentiles y throughput bajo llegadas definidas: más tokens/s totales pueden significar peor experiencia individual.

NivelPreguntaRiesgo
Kernel¿Mejora el operador en esta GPU?Forma, tiempo asíncrono, base débil
Motor¿Mejora con batch/contexto real?Caché incompatible, MoE desigual
Servicio¿Cumple TTFT y cola de latencia?Saturación y caché no comparable
Tarea¿Resultado correcto más barato?Menos calidad disfrazada de eficiencia

Localiza el recurso limitante

El límite roofline compara F/P y D/B: operaciones divididas por capacidad y bytes divididos por ancho de banda alcanzable. Su máximo supone solapamiento perfecto; lanzamientos, sincronización y comunicación añaden límites. El pico anunciado no es rendimiento medido.

Ejemplo didáctico: leer y escribir una matriz FP32 de 4096×4096 mueve 134.217.728 bytes. A 1 TB/s supuesto requiere unos 0,134 ms. Una cifra de 0,01 ms exige revisar caché y cronometraje, no celebrar automáticamente.

Entrega al optimizador perfil, formas, strides y tolerancia. Elimina copias o fusiona operaciones donde importa; conserva la referencia.

Un kernel concreto: normalización RMS

Para X de forma [M,N] y escala w de [N], calcula la media de cuadrados por fila, suma epsilon positivo y multiplica X y w por su raíz inversa. RMSNorm no resta la media. Acumular en FP32 ayuda con entradas de menor precisión, dentro de un rango definido.

Fusionar evita materializar cuadrados e intermedios. Si se rellena una fila para el bloque, los elementos añadidos aportan cero, pero el divisor sigue siendo N. Dividir por el tamaño rellenado es incorrecto.

Filas anchas pueden agotar registros: varias fases cuestan lanzamientos pero pueden ganar. El ejercicio final muestra el contrato y ese error; no mide fusión GPU con Python.

El optimizador es un sistema acotado

El plano de control fija commit, hardware, distribución y presupuesto. El agente propone un parche inmutable; un worker aislado compila y ejecuta. El evaluador controla casos y tiempos: el candidato no edita su juez. Un registro conserva fallos y éxitos como feedback.

Minimiza coste o latencia bajo límites numéricos, de calidad, memoria y cola. Conserva resultados por carga: una media puede esconder regresiones. Usa una frontera Pareto cuando los objetivos chocan. Agotar presupuesto significa detenerse.

Separa ejecución de promoción. Workers sin credenciales productivas, tiempo GPU limitado y suite oculta protegida. Solo un controlador promociona artefactos cualificados con rollback conocido.

Arquitectura: optimización sin saltarse promoción

Diseño original. Rutas de artefactos/peticiones y retorno de mediciones separados. El optimizador queda fuera del límite productivo. Abre la imagen para ampliar.
Diseño original. Rutas de artefactos/peticiones y retorno de mediciones separados. El optimizador queda fuera del límite productivo. Abre la imagen para ampliar.

Evidencia reciente: denominadores distintos

Together (4-11-2026) informa hasta 2,6× TPS en comparaciones InferenceX específicas; OpenAI (29-7-2026), 20% menos coste de servicio por mejoras combinadas; AlphaEvolve (14-5-2025), 23% en un kernel y 1% en tiempo de entrenamiento. Son cifras de autores, no reproducciones nuestras. [1] [2] [3]

Throughput, coste y entrenamiento no constituyen un ranking comparable. Exige modelo, cantidad de hardware, precisión, contexto, concurrencia y límites de latencia.

Mantener motores cargados reduce el coste de experimentar, pero también exige aislar cachés, asignador y configuración entre candidatos. Iterar rápido no debe contaminar mediciones.

Más allá del kernel

La caché de prefijos reutiliza cómputo compatible de prefijos exactos, no de texto simplemente parecido. Sus claves deben incluir revisión y política de aislamiento. No confundas caché caliente con mejoras del kernel.

La decodificación especulativa propone tokens con un borrador y los verifica con el modelo objetivo. El algoritmo correcto de aceptación/corrección puede preservar la distribución. Mejor acuerdo con un borrador mayor puede perder frente a su coste adicional.

Paralelismo tensorial, de expertos y de datos distribuyen trabajo de formas distintas. Más dispositivos añaden comunicación y desequilibrio. Busca con rutas y topología reales: óptimos locales no garantizan el global.

De microsegundos a valor

Si una fracción f del tiempo acelera s veces, Amdahl limita la mejora total. Acelerar 2× el 40% produce solo 1,25× global y 20% menos tiempo. Las colas pueden añadir efectos no lineales.

Ejemplo sintético de 1000 ms: red/cola 200, prefill 300, decode 400, aplicación 100. Reducir decode a la mitad da 800 ms; también prefill, 650 ms. Veinte llamadas estrictamente secuenciales ahorran 4 s si cada una ahorra 200 ms.

Con coste de búsqueda supuesto de $120 y ahorro de $0,0002 por solicitud equivalente, el equilibrio llega a 600.000 solicitudes, antes de mantenimiento. Incluye experimentos fallidos, GPU, tokens y revisión humana.

Presupuesto sintético original: 1000 → 800 → 650 ms, no medición.
Presupuesto sintético original: 1000 → 800 → 650 ms, no medición.

¿Quién controla cada capa?

Wafer comercializa endpoints optimizados por carga y su perfil YC describe agentes como ingenieros de rendimiento. Compras un servicio operativo, no solo un archivo kernel; valida las afirmaciones con tu tráfico. [4]

Together optimiza su servicio; OpenAI su propia pila; AlphaEvolve explora algoritmos. KernelBench es evaluación. Apple lista 37 tareas de soporte, optimización y reparación en motores vLLM/SGLang. [1–3] [5] [6]

Nuestra interpretación: cargas representativas, cualificación y entrega son ventajas duraderas. Pregunta por control de telemetría, aprobación, exportación y fallback. Hosting amortiza búsqueda; despliegue privado exige ingeniería. No es un ranking financiero ni de adquisiciones.

Límites productivos y problemas abiertos

El manifiesto debe fijar código, modelo, compilador, GPU, formas, tipos, tolerancias, resultados y rollback. Solo los casos soportados usan el candidato; el resto conserva fallback válido. Una guarda de forma es código ejecutable.

Observa latencia, errores, OOM, calidad y saturación. Detén promoción si empeoran; drena solicitudes antes de cambios incompatibles de caché. Kubernetes programa recursos y despliegues, no demuestra corrección. Separa cuentas de optimización y producción.

Siguen abiertos transferencia entre hardware, contaminación, deriva numérica, ruido y coste de cualificar. Consultar repetidamente validación la convierte en feedback de entrenamiento. Mantén una carga final independiente y registra sus consultas.

¿Es auto-mejora recursiva?

Existe un bucle si el sistema mejora la pila que ejecutará su siguiente optimización. Caben más experimentos en el mismo presupuesto. Pero un parche demuestra un evento, no amplificación recursiva.

Exige varias generaciones, reglas estables, costes y mejora en tareas reservadas. Compara optimizador fijo, fijo con más presupuesto y supuesto optimizador mejorado. Informa intervención humana y mesetas. Inferencia más rápida no significa mayor capacidad de razonamiento ni aprendizaje de pesos.

Práctica y verificación independiente

Experimento local: rechaza candidatos incorrectos

Ejecuta python3 lab.py con Python 3.11+ y biblioteca estándar, semilla 42. La referencia calcula RMSNorm; el candidato reutiliza la escala; un error divide por anchura rellenada y otro devuelve ceros. El primero pasa anchuras 4/8, pero falla 3/7/33. Son casos públicos didácticos, no una suite secreta. El contrato rechaza escala vacía, anchuras incompatibles y valores no finitos.

Salida esperada: candidate pasa ambos conjuntos; padded_bug solo desarrollo; zero_bug ninguno. Amdahl devuelve 1,25 y equilibrio 600000. gpu_benchmark_performed es false. No se usa tiempo Python para afirmar mejoras GPU; se registra versión sin dependencias externas.

Para extender a GPU, implementa el contrato en CUDA/Triton y registra GPU, driver, compilador, framework y hash. Incluye tamaños impares, ceros, valores grandes, layouts soportados y dtypes. Compara con framework optimizado, separa compilación, sincroniza, usa eventos y repeticiones independientes, aleatoriza orden y controla cargas rivales. Verifica forma, tipo, errores y calidad posterior.

Después reproduce tráfico reservado con modelo, precisión, longitudes, llegadas y caché fijos. Compara configuración manual, búsqueda de parámetros, kernels IA y pila completa con igual presupuesto, incluyendo fracasos. Termina con canary y rollback. Esta extensión GPU no fue ejecutada por Token Lab.

Descargar implementación Python
"""Token Lab: CPU correctness gate, not a GPU performance benchmark.
Python 3.11+ standard library; no network, model API, or third-party dependency.
"""
import json
import math
import random
import sys


def reference(rows, weights, eps=1e-5):
    if eps <= 0 or not weights or any(len(r) != len(weights) for r in rows):
        raise ValueError('positive epsilon and rectangular nonempty rows required')
    if any(not math.isfinite(x) for r in rows for x in r + weights):
        raise ValueError('finite input contract')
    return [[x * w / math.sqrt(eps + math.fsum(v*v for v in r)/len(r))
             for x, w in zip(r, weights)] for r in rows]


def candidate(rows, weights, eps=1e-5):
    output = []
    for row in rows:
        inv = 1 / math.sqrt(eps + math.fsum(x*x for x in row)/len(row))
        output.append([x*w*inv for x, w in zip(row, weights)])
    return output


def padded_bug(rows, weights, eps=1e-5):
    padded = 1 << (len(weights)-1).bit_length()
    return [[x*w/math.sqrt(eps + math.fsum(v*v for v in row)/padded)
             for x,w in zip(row,weights)] for row in rows]


def zero_bug(rows, weights, eps=1e-5):
    return [[0.0]*len(weights) for _ in rows]


def passes(fn, cases):
    for rows, weights in cases:
        expected, actual = reference(rows, weights), fn(rows, weights)
        if len(actual) != len(expected):
            return False
        for a,b in zip(actual,expected):
            if len(a) != len(b) or any(not math.isfinite(x) or
                    not math.isclose(x,y,rel_tol=1e-12,abs_tol=1e-12)
                    for x,y in zip(a,b)):
                return False
    return True


def main():
    rng = random.Random(42)
    dev = [([[rng.uniform(-3,3) for _ in range(n)] for _ in range(3)],
             [rng.uniform(.5,1.5) for _ in range(n)]) for n in (4,8)]
    # Independent shape coverage, public for teaching: NOT a secret benchmark.
    audit = [([[rng.uniform(-3,3) for _ in range(n)] for _ in range(3)],
               [1.0]*n) for n in (1,3,7,33)]
    audit += [([[0.0,0.0,0.0]], [1.0]*3), ([[1000.,-1000.,1.]], [1.0]*3)]
    results = {fn.__name__: {'development':passes(fn,dev), 'audit':passes(fn,audit)}
               for fn in (candidate,padded_bug,zero_bug)}
    assert results['candidate'] == {'development':True,'audit':True}
    assert results['padded_bug'] == {'development':True,'audit':False}
    assert results['zero_bug'] == {'development':False,'audit':False}
    for bad in [([], []), ([[1.,2.]], [1.]), ([[float('nan')]], [1.])]:
        try:
            reference(*bad)
        except ValueError:
            pass
        else:
            raise AssertionError('invalid input accepted')
    speedup = 1 / (.6 + .4/2)
    assert speedup == 1.25
    print(json.dumps({'python':sys.version.split()[0], 'seed':42,
       'correctness':results, 'synthetic_end_to_end_speedup':speedup,
       'synthetic_break_even_requests':120/.0002,
       'gpu_benchmark_performed':False},indent=2))

if __name__ == '__main__':
    main()
{
  "python": "3.12.14",
  "seed": 42,
  "correctness": {
    "candidate": {
      "development": true,
      "audit": true
    },
    "padded_bug": {
      "development": true,
      "audit": false
    },
    "zero_bug": {
      "development": false,
      "audit": false
    }
  },
  "synthetic_end_to_end_speedup": 1.25,
  "synthetic_break_even_requests": 600000.0,
  "gpu_benchmark_performed": false
}

Preguntas originales y respuestas graduadas

1. ¿Por qué 2× local produce 1,25× global?

Pista: fracción acelerada. Con ,4 el tiempo es 0,8. Analiza colas aparte y no sumes mejoras solapadas.

2. ¿Por qué pasa el error de padding?

Pista: anchuras. 4/8 no cambian; usar 4 para reduce la media cuadrática. Añade formas independientes.

3. ¿Puede editar su cronómetro?

Pista: separa propuesta y autoridad. Puede instrumentar diagnóstico, no controlar el evaluador final. Comprueba trabajo GPU completo e inputs frescos.

4. ¿Qué demostraría mejora recursiva?

Pista: un parche no basta. Exige generaciones y ganancias reservadas con presupuesto total controlado, incluyendo humanos y cualificación, frente a optimizador fijo con igual cómputo.

Ejercicios propios, no entrevistas reales. 1 términos; 2 ruta normal; 3 cálculo y detección del error; 4 comparación justa y límites productivos; 5 reproducción independiente, diagnóstico nuevo e incertidumbre.

Rutas relacionadas

Fundamentos explicados

Repasa el razonamiento que sostiene el método y utiliza las comprobaciones para detectar lagunas.

La decodificación autorregresiva genera un token condicionado al prefijo. En un Transformer causal, con prefijo y modelo fijos se reutilizan claves y valores anteriores. La caché KV guarda tensores internos, no una respuesta. Cuenta capas, lote, posiciones, cabezas KV, dimensión y bytes por número.

Razona antes de abrir la solución

Con 2 capas, lote 1, 4 tokens, 2 cabezas KV, dimensión 3 y 2 bytes por número, ¿cuántos bytes ocupan K y V?

Solución paso a paso

2×2×1×4×2×3×2=192 bytes. El primer 2 cuenta K y V. Excluye pesos, temporales, asignación y relleno. Duplicar contexto duplica esta carga, no necesariamente toda la memoria GPU.

Conexión con la práctica

GQA reduce cabezas KV respecto a las consultas. Es una elección arquitectónica, no una licencia para borrar tensores arbitrarios. Reutilizar un prefijo requiere iguales tokens, posiciones, modelo y ajustes relevantes.

Cómo demostrar comprensión

Compara resultados con y sin caché dentro de tolerancia e invalida al cambiar el prefijo. Separa bytes útiles de memoria asignada y prefill de decode. Una calculadora de bytes no mide rendimiento de hardware.

Ejemplo Python completo

Python 3.10+ · solo biblioteca estándar · determinista, sin semilla aleatoria · sin red. Guarda el archivo y ejecuta el comando. Son comprobaciones didácticas, no benchmarks.

Descargar Python · kv.py
python3 kv.py
# Python 3.10+; standard library; deterministic; no network.
def kv_bytes(layers, batch, tokens, kv_heads, head_dim, bytes_per_value):
    dimensions = [layers, batch, tokens, kv_heads, head_dim, bytes_per_value]
    if any(not isinstance(x, int) or x < 0 for x in dimensions):
        raise ValueError("nonnegative integer dimensions required")
    size = 2  # K and V
    for dimension in dimensions:
        size *= dimension
    return size

assert kv_bytes(2, 1, 4, 2, 3, 2) == 192
assert kv_bytes(2, 1, 8, 2, 3, 2) == 384
assert kv_bytes(2, 1, 0, 2, 3, 2) == 0
print("KV payload=192 bytes; doubled context=384 bytes")

Salida esperada

KV payload=192 bytes; doubled context=384 bytes

Repasar el fundamento →

Fundamento revisado:

Referencias, artículos y recursos

  1. Together Compiler — technical report, 2026-11-04 (not claimed as conference acceptance)https://www.together.ai/together-compiler-paper
  2. OpenAI — engineering report, 2026-07-29https://openai.com/index/gpt-5-6-frontier-intelligence-efficiency/
  3. Google DeepMind — AlphaEvolve announcement, 2025-05-14https://deepmind.google/blog/alphaevolve-a-gemini-powered-coding-agent-for-designing-advanced-algorithms/
  4. Wafer — company profile / product positioninghttps://www.ycombinator.com/companies/wafer
  5. KernelBench — ICML 2025 proceedingshttps://proceedings.mlr.press/v267/ouyang25a.html
  6. Apple — RSI-Inference Bench official repository (checked 2026-11-11; no conference status asserted)https://github.com/apple-aiml-research/ml-rsi-inference-bench
  7. KernelBench — arXiv v1, 2025-02-14https://arxiv.org/abs/2502.10517v1
  8. KernelBench — arXiv PDF v1https://arxiv.org/pdf/2502.10517v1
  9. KernelBench — author codehttps://github.com/ScalingIntelligence/KernelBench
  10. AlphaEvolve — original technical PDFhttps://storage.googleapis.com/deepmind-media/DeepMind.com/Blog/alphaevolve-a-gemini-powered-coding-agent-for-designing-advanced-algorithms/AlphaEvolve.pdf
  11. Triton — official kernel tutorialshttps://triton-lang.org/main/getting-started/tutorials/
  12. Wafer — current product descriptionhttps://www.wafer.ai/

Vídeos con propósito

Ver → explicar → implementar → comprobar

Recursos externos en inglés. YouTube gestiona subtítulos y disponibilidad. El reproductor solo contacta con YouTube al pulsar Reproducir; no envía entradas de los experimentos.

Tu siguiente paso

Mide prefill/decode por separado e informa memoria, percentiles de latencia y calidad con igual carga.

Implementar y verificar → · Continuar la ruta →
Guía de estudio y esquema de la lecciónOBJETIVOS DE APRENDIZAJE

Comprender → implementar → investigar

Compara resultados con y sin caché dentro de tolerancia e invalida al cambiar el prefijo. Separa bytes útiles de memoria asignada y prefill de decode. Una calculadora de bytes no mide rendimiento de hardware.

Predecir, comprobar y conservar evidencia

Antes de revelar la respuesta, predice un resultado. Después registra diferencias y una prueba de transferencia. Se guarda localmente y se comparte entre idiomas.

Abrir cuaderno / exportar / borrar →

El alcance de revisión matemática se registra por lección. No certifica reproducción empírica del artículo; anota posibles errores. Alcance de revisión