48 R5 · Manual de tafagent

Qué es. El manual de tafagent, la herramienta de diagnóstico del navegador que acompaña a este libro. Aquí están sus modos, qué métricas calcula, las recetas y cómo leer sus veredictos. Lo importante de entrada, sin malentendidos: tafagent NO dibuja mapas de atención —es un diagnóstico que PREDICE métricas desde la config del modelo—. Para ver mapas, usa BertViz o Transformer Explainer; para medir/predecir γ, horizonte, régimen y KV, usa tafagent.

48.1 Qué es y qué no es

Es: una herramienta en el navegador (cero instalación, cero GPU, sin telemetría) que estima aspectos de viabilidad de un LLM antes de gastar GPU/€: límites de contexto propuestos, degradación por cuantización, plantilla de chat, errores de config.
No es: un visor de mapas de atención, ni un servicio que ejecute el modelo. Lo que ves son predicciones deterministas (calculadas con Pyodide) más una capa de lenguaje natural.
Entrada: un HF model id o un config.json (lee θ, T_train, cabezas…); tú fijas T_eval (la longitud objetivo) y si el modelo usa ventana deslizante (SWA).

48.2 De la pregunta a la herramienta

El selector prepara una ruta: concepto → herramienta → explicación. Los enlaces de Entender este resultado en TAF traen a la guía la métrica seleccionada, su valor y si es una estimación o una medición importada. Ese valor es una instantánea; la guía no ejecuta el modelo ni verifica el resultado. Abre la explicación en otra pestaña para conservar tu diagnóstico, o usa Volver a TAF para preparar el mismo modo.

Buscar un modelo: pulsa el campo opcional para ver modelos populares de Hugging Face, o escribe parte del nombre. Puedes elegir con las flechas y Enter o escribir el ID completo. Las consultas se envían a HF y se guardan en caché en esta pestaña durante cinco minutos. Los resultados se ordenan por descargas, no por fecha; aparecer en la lista no garantiza compatibilidad con TAF. No se descargan pesos ni se inicia un análisis.

Sin JavaScript: perfil, medir atención, comparar con mediciones.

Demo opcional: el botón «Probar un ejemplo» prepara una sonda de atención con Pythia-70m; no descarga pesos ni ejecuta inferencia. En TAF también puedes abrir la demo de lectura acompañada.

Medición de entropía: Diagnose CLI permite generar --entropy-only o --measure-entropy. La inferencia se ejecuta con Python/PyTorch en tu equipo; no dentro de este selector. La entropía no determina γ y no se aplica una corrección automática por entropía. El diagrama de fases consulta el atlas, no realiza una nueva medición.

48.3 Resolver mi problema: de la duda a la comprobación

Piensa en un mostrador de diagnóstico: llegas con «no me funciona» y recibes las preguntas que permiten acotar el problema. No necesitas conocer de antemano el nombre de cada módulo. Resolver mi problema hace ese recorrido automáticamente en el navegador, sin un operador ni un servicio de chat.

La ventana comienza por lo que te ocurre, no por el nombre del módulo. Elige entre memoria, respuestas, adaptadores, acceso/carga, contexto largo, evaluación o rendimiento. Una segunda pregunta acota el caso: por ejemplo, si falta memoria al cargar, al generar o durante el entrenamiento. Son siete familias y veinte situaciones. La ruta de entrenamiento distribuido explica su límite y remite a la guía; no aplica una estimación de inferencia.

Si ya sabes qué comprobar, puedes abrir directamente las nueve rutas:

Los enlaces solo abren el formulario. Cada ruta tiene Probar un ejemplo sin conexión: puedes explorar sus respuestas antes de introducir tu modelo. El ejemplo de memoria permite recalcular con menos contexto o comparar un formato de pesos; cambia la estimación, no ejecuta ni modifica el modelo.

Los seis casos nuevos analizan datos pegados localmente, sin descargar pesos. El JSON reordenado es una propuesta que puedes revisar y volver a comprobar; no valida todo el esquema ni garantiza la calidad. La comparación de prompts no predice precios ni aciertos de caché. Una diferencia de evaluación no prueba un bug y una gamma importada no es una nueva inferencia. Los informes excluyen código, prompts, archivos pegados y propuestas JSON.

El selector Buscar herramienta para otro problema conecta los 31 modos: explica qué datos requiere cada uno, qué calcula y qué no permite concluir. Incluye formulario especializado, demo opcional y lectura de la guía. Algunas herramientas necesitan Pyodide, archivos de red, Python local o WebGPU; abrirlas no significa que ya hayan diagnosticado el problema. Las preguntas parten de una muestra pública de discusiones, no de una clasificación estadística ni de vigilancia automática.

Revisar este resultado. Tras cada comprobación directa puedes desplegar una revisión de la evidencia: en qué se apoya el resultado, qué queda sin verificar y cómo comprobarlo, con un enlace a la explicación de esta guía. El panel distingue estimaciones de configuración, inspecciones estáticas, comparaciones heurísticas y mediciones importadas. No ejecuta otro modelo ni asigna una probabilidad de fallo. En los informes de atención mantiene visibles los datos de protocolo ausentes y los avisos de comparación.

Por ejemplo, un presupuesto de memoria que cabe no prueba que tu carga real quepa: TAF no mide picos de carga, buffers ni concurrencia; los picos declarados siguen sin verificar. La comprobación siguiente propone probar una petición corta y observar la memoria libre en la fase del fallo. Los ejemplos guardados o sintéticos siguen identificados como demos, no como diagnósticos de tu modelo. La demo guiada abre este panel; el informe descargable lo incluye sin añadir los textos pegados.

Volver sin perder la ruta. Si llegas a la guía desde el resumen o la revisión de un caso, el enlace Volver al formulario de este problema conserva la ruta, el idioma de TAF y el alojamiento de origen (GitHub o Hugging Face). Prepara el formulario; no ejecuta una comprobación ni restaura los datos pegados. Conserva la pestaña original para consultar el resultado completo. Los ejemplos no transmiten un ID de modelo como si fuera el tuyo.

Del aviso al siguiente paso. En Resolver mi problema → Atención, pega uno o dos informes con γ y abre Ver detalles del protocolo. El panel enumera 19 condiciones conocidas en cuatro grupos: modelo/datos, muestreo, ejecución y agregación/ajuste. Marca lo ausente y lo que difiere de la referencia. Los campos personalizados cuentan, pero sus nombres y valores no se exportan.

Qué comprobar primero da prioridad a las contradicciones o límites de contexto, después a las diferencias entre protocolos y a los datos pendientes. Si todo está documentado y coincide, propone revisar la curva y repetir la medición. Recupera los ajustes de la ejecución real; no los inventes para hacer coincidir informes. Un campo documentado no demuestra que sea correcto ni valida la teoría. La demo opcional de esa ruta utiliza atención uniforme sintética para mostrar datos pendientes; no ejecuta un modelo. La guía permite volver al mismo formulario.

Pasos ordenados en ocho rutas. Ver los pasos de comprobación muestra tres instrucciones: qué revisar primero, qué observar en tu entorno y cómo interpretar o redirigir el caso. Se elige entre 41 prioridades según el resultado. Atención conserva su lista específica de protocolo: las nueve rutas acompañan el siguiente paso. Recalcular actualiza resumen, revisión y «Sigue fallando».

Explorar otro ejemplo ofrece 33 situaciones: cinco de memoria, tres de plantillas, tres de adaptadores, cinco de caché, cinco de evaluación, tres de arquitectura, tres de JSON y seis de código PEFT. Cambiar de ejemplo reinicia la comparación y mantiene su etiqueta ilustrativa. Los ejemplos alternativos de arquitectura retiran el ID, revisión y fuentes anteriores para no atribuir una configuración sintética al modelo real.

El informe conserva el plan con executed: false. TAF no ha ejecutado esas comprobaciones ni certificado una reparación. La demo animada de memoria enseña los pasos. Puedes profundizar en arquitectura, código PEFT, JSON, caché y latencia y diferencias de evaluación. Los capítulos 20 y 28 también explican los presupuestos de memoria y adaptadores. Volver abre el mismo formulario en el alojamiento e idioma originales, sin transmitir código, prompts ni resultados privados.

48.3.1 Continuar después de comprobar: seguimiento opcional

Seguir mis comprobaciones permite indicar qué has podido revisar sin perder el resultado actual. Está disponible en las nueve rutas. Cada paso admite cuatro estados: pendiente, revisado sin discrepancias detectadas, discrepancia encontrada o no se ha podido comprobar. Son declaraciones del usuario, no pruebas ejecutadas ni verificadas por TAF.

El siguiente paso se selecciona automáticamente: primero la primera discrepancia, después el primer bloqueo y luego el primer pendiente. Ir a la siguiente comprobación lleva al control correspondiente. «Sigue fallando» utiliza ese seguimiento junto al plan basado en los datos originales. El enlace a la guía continúa explicando el caso; las marcas no cambian los resultados ni el protocolo. Marcar los tres pasos como revisados no certifica una solución: hay que comprobar la tarea original y conservar los contraejemplos si persiste el fallo.

Demo opcional: en un ejemplo guardado, Simular una comprobación bloqueada marca un paso revisado, otro bloqueado y otro pendiente. La demo animada muestra este recorrido en su quinto paso. Estas marcas son ilustrativas; no representan una ejecución. El botón de simulación no aparece en un caso con datos propios.

Sin guardar un caso privado, las marcas se conservan solo en la pestaña original al cerrar el panel o cambiar idioma. Cambiar datos, recalcular, escoger otro ejemplo o ruta las borra; recargar la página también las pierde. El informe incluye el seguimiento como declaraciones sin verificar y no contiene notas libres, prompts ni código pegado. No permite restaurar la sesión. Los enlaces de la guía abren un formulario nuevo: mantén abierta la pestaña original o guarda un caso privado para retomarlo después.

48.3.2 Continuar con lo que observaste

Después de probar una comprobación, abre ¿Qué ocurrió al comprobarlo?, selecciona el paso y el resultado observado. Sigue fallando abre ese panel. Las nueve rutas ofrecen 27 observaciones concretas y una opción para indicar que no pudiste obtener la evidencia.

Por ejemplo, si una petición corta funciona y una larga falla, TAF propone fijar modelo, precisión y concurrencia, aumentar gradualmente los tokens y registrar el pico de VRAM. Si falla antes de generar, propone revisar la memoria durante la carga y el formato real de pesos. En JSON distingue sintaxis inválida, incumplimiento del esquema y respuesta incorrecta con formato válido. La siguiente instrucción depende de lo que indicas; el análisis original permanece visible y no se convierte en una reparación verificada.

Se conservan las últimas doce observaciones del resultado, en orden. Cambiar idioma o cerrar el panel las conserva; cambiar datos, recalcular, elegir otro caso o ejemplo y recargar las borra. Borrar observaciones no borra el análisis ni las marcas de progreso. El informe las incluye como declaraciones, sin texto libre, y no permite restaurar una sesión. Las herramientas sugeridas abren su ficha: sus resultados no vuelven automáticamente al caso.

La demo interactiva muestra una observación simulada en el quinto paso. El vídeo grabado muestra el flujo anterior de marcas de progreso; para ver las observaciones utiliza la demo interactiva. La demo independiente de Fit Check usa una configuración guardada de Qwen3-8B y calcula el presupuesto sin consultar HF: 24 GiB, pesos BF16 y caché FP16. Es una ilustración, no una medida de tu GPU.

Un caso concreto: los pesos pueden caber en una GPU y la generación superar su memoria al añadir la caché KV. La ruta pregunta por la memoria disponible, los tokens totales, el formato de pesos y si falla al cargar o al generar. Reutiliza Fit Check para separar esos componentes. Es una estimación para una GPU y una secuencia, no una medición de tu equipo ni un diagnóstico garantizado del error.

En las otras rutas, encontrar una plantilla no demuestra que el programa la aplique correctamente, y reconocer una arquitectura no certifica su calidad ni su soporte en todos los motores. TAF muestra qué archivos consultó y su revisión, explica las limitaciones y propone la siguiente comprobación.

Puedes indicar Lo probé y funcionó o Sigue fallando, abrir la herramienta detallada, leer el capítulo correspondiente y descargar el informe. Las preguntas y errores pegados permanecen en la pestaña; HF recibe las consultas de modelos. El enlace para compartir lleva solo la ruta, el ID y el idioma; no lleva errores, hardware ni resultados. Las respuestas compartidas no se publican automáticamente en HF. La nota técnica describe el alcance y cómo ampliar las rutas con otros módulos.

48.3.3 Cabe según la estimación, pero falla: fases y picos

El presupuesto estable y el pico de una fase son cantidades distintas. En la ruta de memoria puedes indicar carga, prefill (procesamiento del prompt), decodificación (tokens posteriores) o fase desconocida. Una llamada a generate() puede incluir prefill y decodificación: medir su máximo no separa ambas fases. Si no conoces la frontera, conserva «fase desconocida».

Fase	Referencia y siguiente comprobación
Carga	Pesos residentes, sin afirmar que predicen el pico. Revisa copias temporales, conversión y memoria libre antes de cargar.
Prefill	Presupuesto con los tokens del prompt. Aísla ese procesamiento; comprueba buffers temporales de atención/logits y backend realmente usado. Acorta solo el prompt al repetir.
Decodificación	Presupuesto con los tokens realmente almacenados: prompt más tokens generados. Reinicia contadores después del prefill; revisa crecimiento KV, salidas retenidas y concurrencia. Mantén el prompt fijo al variar la longitud generada.

Pico de memoria observado es opcional. Introduce la medida, su unidad (GiB, GB decimal o MiB) y qué representa: tensores asignados por PyTorch, memoria reservada por su asignador, uso muestreado del dispositivo o métrica desconocida. El tamaño de la asignación solicitada en un error OOM no es un pico observado. No introduzcas cero para suplir una medida ausente.

La diferencia numérica solo aparece para un pico de tensores asignados, una fase conocida, una medida aislada de esa fase y la misma carga: modelo, formato, tokens, una GPU, una secuencia, pesos residentes y KV FP16. También hace falta geometría admitida. Carga se compara con pesos residentes; prefill/decodificación con la estimación estable. Son referencias, no predicciones del máximo real. La memoria reservada y el uso del dispositivo quedan como contexto, sin restarlos de una estimación que cuenta otras cosas.

La diferencia no mide fragmentación, no prueba una causa ni certifica una solución. Un pico bajo el presupuesto no descarta OOM: una asignación fallida no pasa a formar parte de la memoria asignada con éxito. TAF tampoco verifica la medición aportada. El informe distingue user_reported de illustrative y mantiene independently_verified: false y executed_by_taf: false.

Cómo medir en tu entorno. Identifica la GPU y la frontera de la fase; registra versiones, formato real, backend, tokens y opciones relevantes. Con PyTorch, sincroniza ese dispositivo antes de empezar, llama a torch.cuda.reset_peak_memory_stats(device), ejecuta solo la fase delimitada y vuelve a sincronizar antes de leer torch.cuda.max_memory_allocated(device) y torch.cuda.max_memory_reserved(device). Ambos valores se expresan en bytes: divide por 2**30 para GiB. Reiniciar contadores no libera los tensores ya residentes. Si no puedes separar prefill de decodificación, registra el máximo global con fase desconocida. TAF no ejecuta estas operaciones.

La documentación de memoria de PyTorch explica las diferencias entre asignado, reservado y uso mostrado por el dispositivo. Consulta también el contador máximo de tensores y el reinicio de picos.

Ejemplo guardado. En «Explorar otro ejemplo», elige «cabe según la estimación, pico mayor en prefill». Usa geometría guardada de Qwen3-8B, BF16, 4.096 tokens y 24 GiB disponibles, con un pico sintético de 22 GiB. Ilustra la diferencia; no es un benchmark medido de Qwen ni demuestra un OOM. Cambiar modelo, presupuesto, tokens, precisión o fase borra la medida; aplicar una alternativa requiere medir de nuevo. Cambiar de idioma la conserva. El informe separa los datos iniciales de los actuales y el enlace compartido no incluye medidas.

48.3.4 Guardar un caso y retomarlo otro día

Después de una comprobación, abre Guardar caso privado. Lee el aviso y pulsa el botón para descargar el archivo JSON. Conserva entradas iniciales y actuales, metadatos, pasos marcados, observaciones y la respuesta «funcionó» o «sigue fallando» en las nueve rutas directas.

Este archivo no está cifrado y puede contener los textos, código, informes o configuraciones privados que pegaste. Guárdalo en tu dispositivo y revísalo antes de compartirlo. TAF no lo sube ni guarda una copia automáticamente en el navegador. Exportar informe sigue creando el informe reducido que omite los textos y código de las rutas locales; ese informe no permite recuperar datos que se eliminaron.

Para continuar, abre Resolver mi problema → Abrir caso guardado, elige el archivo (máximo 4 MiB), comprueba la ruta y fecha y pulsa Abrir y sustituir el caso actual. Cancelar o seleccionar un archivo inválido conserva el caso actual. Puedes abrirlo en cualquiera de los dos alojamientos de TAF.

Al recuperar se recalculan las comprobaciones con la versión actual de TAF, sin consultar Hugging Face, ejecutar código pegado ni ejecutar el modelo. Se conserva el idioma actual. Los metadatos y revisiones del archivo se etiquetan como no verificados y los ejemplos siguen siendo ilustrativos. Si el plan de comprobación ha cambiado se descarta el seguimiento incompatible. Para obtener metadatos actuales del repositorio, vuelve a ejecutar la comprobación de HF. Recuperar un caso no prueba que una solución haya funcionado.

48.3.5 Incorporar una medición de memoria al caso

Primero calcula tu caso de memoria con el modelo, revisión consultada, formato, fase y tokens. Después abre Importar medición de memoria, selecciona un JSON taf-memory-measurement (hasta 64 KiB) y revisa las condiciones declaradas. La previsualización indica coincidencias, diferencias y datos sin documentar. Pulsa Incorporar pico a este caso para rellenar únicamente pico, unidad y métrica; no se cambian el modelo, fase, precisión ni longitud del caso.

Las confirmaciones de misma carga y fase aislada quedan desmarcadas. Revísalas en tu entorno y repite la comprobación. Marcarlas no anula diferencias ni datos ausentes del archivo. Modelo, revisión, fase, formato y carga deben concordar; una GPU, una secuencia, pesos residentes y KV FP16 delimitan la comparación. En carga no se exige longitud ni tipo KV, porque la referencia son los pesos. Los picos reservados, de dispositivo o de fase desconocida quedan como contexto. Un archivo ilustrativo tampoco habilita una diferencia numérica.

Cómo obtener el informe. El auxiliar memory_probe.py se importa en tu programa PyTorch/CUDA y rodea la operación que tú ejecutas. No instala dependencias, carga modelos ni ejecuta tareas por su cuenta. El ejemplo siguiente usa variables y una función de tu programa; no es un benchmark listo para ejecutar:

from cli.memory_probe import memory_probe

with memory_probe(
    "prefill-memory.json", model=MODEL_ID, revision=MODEL_COMMIT,
    phase="prefill", tokens=ACTUAL_PROMPT_TOKENS, precision=WEIGHT_FORMAT,
    device=CUDA_DEVICE, phase_isolated=PHASE_WAS_ISOLATED,
    gpu_count=GPU_COUNT, batch_size=SEQUENCE_COUNT,
    resident_weights=WEIGHTS_RESIDENT, kv_dtype=ACTUAL_KV_DTYPE,
) as record:
    outputs = run_your_prefill()

El auxiliar sincroniza la GPU elegida, reinicia contadores, espera a que tu bloque termine, vuelve a sincronizar y escribe el máximo de tensores asignados en MiB, con versión de PyTorch, dispositivo y fecha. metric="reserved" recoge el máximo reservado. Los metadatos de modelo y carga son declaraciones tuyas; deja None si no los conoces. La revisión debe ser un hash completo, no main.

Para una llamada completa a generate(), usa phase="generate": no demuestra la separación de prefill y decodificación. En decodificación registra la longitud real de caché en el punto comparado, no el máximo configurado; puedes completar record["tokens"] dentro del bloque. Aísla otras actividades y no solapes medidores en la misma GPU: los contadores pertenecen al proceso/dispositivo. Si el bloque falla, incluso por OOM, no se escribe un informe nuevo ni se oculta el error. Los archivos existentes no se sobrescriben. Reiniciar máximos no libera memoria.

Guardar y compartir. El caso privado conserva el informe normalizado con los detalles del entorno. Usa v2 si solo hay una medición; si las entradas actuales o iniciales contienen una pareja antes/después, usa v3, como se explica en la sección siguiente. Sin mediciones usa v1. El lector actual acepta las versiones v1–v4. Recarga una pestaña antigua antes de abrir un archivo de una versión más reciente. El informe reducido conserva el pico y categorías de comparación, pero omite el registro original y sus identificadores del entorno. Cambiar modelo, presupuesto, longitud, formato o fase elimina la medición; editar pico/unidad/métrica la convierte en una entrada manual. Ninguna coincidencia verifica la medida ni una reparación.

Consulta formato completo, ejemplo ilustrativo y pruebas y la documentación de contadores de PyTorch. La interfaz y la ayuda están disponibles en ES/EN/FR/ZH; el navegador no ejecuta código de los archivos ni realiza medidas GPU.

48.3.6 Comparar memoria antes y después

Después de incorporar y confirmar la primera medición, abre Comparar antes y después. La medición adjunta es Antes. Selecciona un segundo JSON local como Después (el mismo formato, hasta 64 KiB), revisa condiciones, motor y fechas, y pulsa Incorporar como Después. El primer pico y los ajustes del caso se conservan. Cada incorporación deja desmarcada la confirmación de ambas ejecuciones.

Comprueba tú mismo que coinciden entrada/carga, equipo físico y protocolo, y que las fases estuvieron aisladas. La etiqueta de dispositivo 0 no identifica por sí sola la GPU ni el ordenador. También deben seguir confirmadas la carga y el aislamiento del pico inicial. Incorporar o confirmar recalcula localmente, sin consulta HF, y reinicia progreso, observaciones y respuesta final.

Los dos archivos deben concordar con modelo, revisión, fase, formato y carga del caso. Motor, versión y etiqueta de dispositivo han de estar documentados y ser idénticos. Ambas fechas son necesarias y Después debe ser estrictamente posterior. Las fechas y etiquetas siguen siendo declaraciones sin autenticar. Se conservan los límites anteriores: tensores asignados, fase conocida, una GPU, una secuencia y geometría admitida. Datos ausentes o distintos, ejemplos, máximos reservados/de dispositivo, generación completa o falta de confirmación bloquean la diferencia. La confirmación no anula discrepancias. Esta versión no compara cambios de modelo, precisión, contexto, versión del motor o equipo: necesitan otro protocolo controlado.

Se muestran ambos picos en GiB. Si son comparables, se calcula después − antes y su porcentaje respecto a Antes. Si el pico inicial es cero, el porcentaje queda indefinido aunque pueda calcularse la diferencia absoluta. Una diferencia negativa solo indica un pico posterior declarado menor. Dos ejecuciones no permiten estimar incertidumbre ni demostrar causalidad, calidad o que un OOM esté resuelto. Repite mediciones controladas antes de concluir.

Quitar medición posterior conserva Antes. Sustituir la primera elimina Después y su confirmación. Cambiar identidad, presupuesto, longitud, formato o fase borra ambas; editar manualmente el primer pico separa los dos registros. Cambiar idioma conserva los datos aplicados; un archivo inválido no altera la pareja existente.

El caso privado v3 conserva ambos registros normalizados en las entradas actuales/iniciales. Sin pareja usa v2 si hay una medición, o v1 si no hay ninguna; el lector actual acepta las versiones v1–v4 y recalcula. Recarga la aplicación antes de abrir v3 en una pestaña antigua. El informe reducido guarda picos, diferencias y categorías, pero omite ambos registros y sus detalles privados. El formato del JSON de medición sigue siendo v1.

Consulta contrato, privacidad y pruebas de la comparación. La interfaz y ayuda están en ES/EN/FR/ZH. Las pruebas usan datos ilustrativos; no se ejecutó una nueva medición real en GPU para validar esta función.

La revisión de las 35 demos del 25-10-2026 detalla los recorridos comprobados en ES/EN/FR/ZH y las incidencias del entorno de pruebas. No implica que los vídeos anteriores muestren la nueva importación o comparación de archivos ni garantiza disponibilidad futura.

48.3.7 Abrir archivos de informes de atención

En la ruta de atención de Resolver mi problema, puedes abrir un JSON como informe principal o referencia opcional sin copiarlo y pegarlo. Debe ser un único objeto con gamma o gamma_obs numérica y finita, de hasta 50 kB (50.000 bytes). Cero es válido; texto, null o ausencia de gamma no equivalen a una medida.

Abre Abrir archivo del informe principal o Abrir archivo del informe de referencia, selecciona el JSON y revisa la vista previa: gamma declarada, modelo/revisión/fuente, clasificación del contexto y campos de protocolo pendientes. Las etiquetas largas se acortan solo en esa vista. Usar este informe sustituye únicamente el campo elegido; el otro se conserva. Descartar vista previa deja el caso intacto, igual que un archivo inválido o demasiado grande.

Después pulsa la comprobación para analizar ambos campos. Aplicar el archivo borra el resultado y seguimiento anteriores; no ejecuta automáticamente el análisis. La comprobación mantiene las reglas existentes: longitudes variables de Diagnose CLI, N heredado, conflictos entre T_eval y el protocolo y condiciones ausentes no pasan a ser datos comparables por importar un archivo.

No se ejecutan modelos, Python ni código del JSON y no hay subida ni consulta HF. El contenido y sus etiquetas no autentican su origen: puede ser un ejemplo, aunque indique diagnose-cli. Los informes solo de entropía no proporcionan gamma; tampoco se aceptan colecciones, archivos comprimidos o informes que superen el límite. No elimines condiciones de protocolo solo para reducir el tamaño. Este importador limita también la estructura a 20 niveles de anidación y 25.000 valores visitados.

El texto completo, incluidos campos desconocidos y posibles datos privados, queda en la entrada y en Guardar caso privado. Se elimina un BOM inicial y el área de texto normaliza saltos de línea a LF; no se descartan curvas ni campos del JSON. El caso de atención sigue usando formato privado v1, pues conserva los mismos dos campos de texto. El informe reducido omite esos textos y nombres privados de protocolo. El archivo privado no está cifrado ni se redacta automáticamente.

Editar entradas, cambiar de ruta, volver a comprobar o elegir otro archivo invalida vistas previas antiguas. Cambiar idioma conserva textos aplicados; una lectura que termine tarde no puede sustituirlos. El archivo original y su nombre no se guardan como adjunto: el caso conserva el contenido del campo.

Consulta formato admitido, privacidad y pruebas. UI y ayuda disponibles en ES/EN/FR/ZH; los vídeos anteriores no muestran estos selectores. El control uniforme incluido es sintético, no una nueva medición GPU.

48.3.8 Abrir la configuración de un adaptador

En Resolver mi problema → Adaptadores, escribe la base que pretendes usar, abre Abrir archivo de configuración del adaptador y selecciona adapter_config.json. El límite es 50 kB (50.000 bytes UTF-8). La vista previa muestra tipo PEFT, base, revisión, tarea, rango y alpha declarados cuando existen; acorta las etiquetas largas solo para mostrarlas.

Usar esta configuración sustituye únicamente el JSON. El campo de modelo base se conserva, incluso vacío, para que la comprobación pueda detectar discrepancias con la base declarada. Pulsa después la comprobación: aplicar no ejecuta el análisis y borra el resultado y seguimiento anteriores. Descartar vista previa o un archivo inválido conserva el caso. Editar, cambiar de ruta, volver a comprobar o elegir otro archivo invalida vistas antiguas y lecturas tardías.

Se exige un objeto con peft_type no vacío. Los metadatos presentes deben tener tipos correctos: rango entero positivo, alpha finito no negativo, bases/revisiones/ tareas de texto, indicadores booleanos y objetivos de texto o listas de texto. Los patrones de rango/alpha son objetos numéricos. Se limita la estructura a 20 niveles y 25.000 valores; se conservan campos desconocidos y valores opcionales ausentes. Es una comprobación básica de formato, no todo el esquema PEFT. Los tipos PEFT desconocidos no certifican soporte; soft prompts mantienen sus reglas.

No se cargan pesos, ejecuta código o entrenamiento, mide calidad ni consulta HF. La procedencia no está verificada y la revisión mostrada no se compara con la revisión real de la base. Una coincidencia de familia no prueba identidad exacta. Las expresiones de objetivos se conservan como texto, sin ejecutarlas.

El JSON completo, incluidos campos desconocidos, rutas o notas privadas, queda en Guardar caso privado, formato v1. No está cifrado ni se redacta. El informe reducido omite el JSON y el texto de la base. Se retira un BOM inicial y el área de texto normaliza saltos de línea a LF; el original no se modifica ni se guarda su nombre. Cambiar idioma conserva el texto aplicado y descarta su vista previa.

Consulta formato, privacidad y pruebas. La interfaz y ayuda están en ES/EN/FR/ZH. Los vídeos anteriores no muestran este selector; las pruebas usan metadatos sintéticos, sin entrenar un adaptador.

48.3.9 Abrir archivos JSON, de código y prompts

Las rutas JSON, código PEFT y prefijos de prompts de Resolver mi problema admiten archivos locales UTF-8 de hasta 50 kB (50.000 bytes). Cada prompt tiene su propio selector. Abre el control bajo el campo, selecciona .json, .py/.txt o .txt respectivamente y revisa la vista previa literal. Muestra bytes, líneas y hasta 12 líneas/1.200 caracteres; indica si es parcial. Una línea vacía final cuenta cuando el texto termina en salto de línea.

Usar este texto conserva el contenido completo aceptado y sustituye solo el campo elegido. El otro prompt se mantiene. Borra el resultado y seguimiento anteriores; después debes ejecutar la comprobación. Cancelar o un archivo inválido deja el caso intacto. Editar, cambiar ruta, comprobar o elegir otro archivo invalida lecturas tardías; cambiar idioma conserva texto aplicado y descarta la vista previa.

Se rechazan UTF-8 inválido, texto vacío o solo espacios, NUL y tamaño excesivo. Se elimina un BOM inicial y se normalizan CRLF/CR a LF, conservando los demás espacios. Esto significa que dos archivos con distintos saltos pueden producir el mismo texto. La comparación de prompts sigue contando prefijo en unidades UTF-16: no compara bytes originales, tokens ni aciertos reales de caché.

JSON debe ser un objeto con tipos básicos válidos en properties/required, sin números no finitos, máximo 20 niveles y 25.000 valores. No se valida todo JSON Schema ni se garantiza calidad de razonamiento. Los campos desconocidos se conservan y reordenar sigue siendo una opción explícita. El código PEFT se lee como texto: las comprobaciones existentes usan patrones, sin ejecutar Python ni validar su sintaxis. No se extraen celdas de notebooks ni se convierten PDF/archivos.

No hay subida, consulta HF ni envío de prompts a un modelo. El texto se muestra literalmente, sin ejecutar HTML o scripts. La extensión no verifica contenido ni autoría. Guardar caso privado, formato v1, conserva texto normalizado completo, que puede contener secretos, código o prompts; no está cifrado ni se redacta. El informe reducido omite esos textos y la propuesta de reordenación. El original no se modifica ni se guarda su nombre. Los enlaces no incluyen texto.

Consulta contrato, privacidad y pruebas. Interfaz y ayuda ES/EN/FR/ZH; los vídeos anteriores no muestran estos controles. Las pruebas usan ejemplos sintéticos, sin modelos, entrenamiento ni medición de caché.

48.3.10 Observar el uso real del dispositivo

El recolector opcional cli/device_memory_probe.py consulta NVIDIA sin cargar ni detener modelos. Ejecuta python cli/device_memory_probe.py --output device-window.json --seconds 5 e importa el JSON como medición de memoria. Registra el máximo muestreado de todo el dispositivo, incluidos otros procesos y la lectura inicial; puede perder picos breves. Se conservan número de muestras, intervalos reales, duración, uso inicial y capacidad. El máximo no se atribuye a llama.cpp ni a una fase aislada. Para separar carga, prefill y decode hay que instrumentar y esperar cada fase en el programa propio. La interfaz ES/EN/FR/ZH explica esta procedencia; no calcula diferencias numéricas con estimaciones ni entre parejas para esta métrica. Errores no generan un informe nuevo y los archivos existentes no se sobrescriben.

Contract / Contrato.

48.3.11 Leer logs de memoria de llama.cpp

Después de comprobar un caso de memoria, abre Leer un log de memoria de llama.cpp. Selecciona un archivo .log/.txt UTF-8 de hasta 256 KiB, o pega el texto y pide una vista previa. Usa un fragmento de una sola inicialización. Adjuntar log a este caso recalcula localmente, sin subir el archivo ni ejecutar un modelo. No cambia los parámetros del caso ni rellena el campo de pico.

La tabla separa pesos, caché KV, estado recurrente, cálculo y salida por ubicación. CPU_Mapped y CUDA_Host siguen siendo memoria del lado CPU; cada CUDA0, CUDA1, etc. aparece por separado. Los backends no reconocidos quedan sin clasificar. Son tamaños de búfer declarados, no el pico ni el uso total de VRAM. Los subtotales solo suman líneas reconocidas; pueden faltar controlador, escritorio, otros procesos y asignaciones posteriores. Una asignación ausente no equivale a cero. Los búferes o metadatos repetidos bloquean subtotales y diferencias, pues pueden corresponder a recargas, fragmentos o ejecuciones mezcladas.

Para calcular declarado − estimado, confirma primero el modelo/revisión, formato de pesos y condiciones de la ejecución. La confirmación no sustituye los datos ausentes. Se exige estimación compatible, compilación identificada, una GPU CUDA y transferencia completa de capas. La comparación de pesos se bloquea si también hay pesos en CPU. Para KV se requiere un máximo de una secuencia, K/V FP16, contexto y celdas iguales al caso, sin estado recurrente. La fase de carga no compara KV. Cuantización de caché, reparto CPU/GPU, arquitectura fuera de ámbito o metadatos insuficientes mantienen los datos visibles sin una diferencia válida. El resultado no acredita que el modelo quepa ni que haya desaparecido un OOM.

El ejemplo integrado es sintético y solo de vista previa; no se adjunta como medición. El lector admite patrones concretos de inicialización en MiB: formatos con prefijos distintos pueden no reconocerse. No se interpreta cualquier error o cifra como memoria. La procedencia y completitud del log no se autentican.

Se rechazan UTF-8 inválido, NUL, vacío y tamaño excesivo. Se retira BOM y se normaliza CRLF/CR a LF. Guardar caso privado, versión 4 cuando contiene logs, conserva el texto completo, incluso posibles rutas o secretos, sin cifrado ni redacción. El informe reducido omite el texto y conserva cifras y comprobaciones. No se guarda el nombre del archivo ni se incorpora el log a enlaces. El lector acepta también casos v1–v3 y recalcula; versiones antiguas de la app rechazan v4.

Cambiar idioma conserva el log adjunto. Cambiar modelo, presupuesto, contexto, precisión o fase lo retira. Adjuntar, confirmar o retirar reinicia el seguimiento; archivos inválidos y vistas previas canceladas conservan el caso. Importar picos PyTorch y comparar antes/después sigue siendo un flujo separado.

Consulta el contrato y las pruebas. Interfaz y ayuda ES/EN/FR/ZH. Las pruebas son sintéticas; no se midió ninguna GPU. Los vídeos anteriores no muestran este panel.

48.4 Elegir un modelo sin confundir reconocimiento y validación

Una ficha técnica sirve como un plano: describe piezas, pero no demuestra cómo se comporta la máquina. La búsqueda de Hugging Face encuentra nombres; el importador necesita además una arquitectura compatible; medir la atención requiere ejecutar los pesos con un protocolo. Son tres pasos distintos.

Revisión del 24-10-2026: TAF incluye ocho configuraciones públicas fijadas a una revisión y dos configuraciones Gemma 3 restringidas que quedan sin verificar. Conserva los once ejemplos históricos y añade dos perfiles densos Qwen3. Puedes explorar estos ejemplos guardados sin descargar pesos:

El panel muestra procedencia y límites antes de cargar valores. No inicia un análisis. Las importaciones automáticas de Profile, recetas, Inspector, Compare, Depth, Fit Check y Launch rechazan los supuestos densos no compatibles: capas híbridas, MoE, MLA, ventanas mixtas, RoPE parcial/escalado o componentes multimodales. Los otros modos conservan su propio alcance; los ejemplos históricos pueden simplificar la arquitectura. Un rechazo no significa que el modelo sea defectuoso.

Ejemplo de lectura cuidadosa: la ficha oficial de Qwen3-8B indica 32.768 tokens de contexto nativo, mientras que su configuración declara 40.960. Los dos nuevos perfiles guardados usan 32.768 como referencia. Al importar una configuración en directo, TAF etiqueta el contexto configurado como referencia provisional: max_position_embeddings no demuestra la longitud de entrenamiento. Verifica T_train antes de interpretar las fórmulas. El número de parámetros importado también es una estimación, no una medición de los pesos.

Si editas la geometría de Profile, TAF desvincula el modelo y pasa a un escenario manual. Si una nueva carga falla, no ejecuta los valores anteriores bajo el nuevo nombre. Entender las arquitecturas ayuda a elegir el siguiente paso; la nota técnica de la revisión detalla fuentes y pruebas. Esta actualización no añade mediciones al atlas ni actualiza las tablas de benchmarks.

48.5 Las métricas que calcula

Métrica	Qué dice	Cap.
γ_Padé	γ predicho desde la geometría (θ, T)	15
γ_observado	γ importado de una medición con pesos reales; depende del protocolo	15
d_horizon	horizonte derivado del modelo teórico; no prueba el contexto útil real	15, 19
η (θ_eff_obs/θ_eff_Padé)	régimen: Normal / Fraude / Comprimido / Over-Padé / SWA	R1
KV memory	memoria de caché a la longitud L	20, 36
L_NIAH	techo estimado needle-in-haystack	19
Δγ	sonda de fase de cabezas de inducción	24, 30
ΔPPL	shift de perplejidad por cuantización	35
Fase A / Fase B	γ<1 (global) vs γ>1 (colapso local)	21

48.6 Cómo se organiza: cinco preguntas, no una lista de modos

La portada agrupa las herramientas por lo que quieres hacer (los modos crecen con cada versión; la lista siempre actual está en el manual 📘 de la propia app):

🔬 “¿Me sirve este modelo?” — Profile (pega un id → la TAF Card completa, el modo de partida), Fit Check, Unmask, Memory Reality, NIAH→Reason, LongScore, Quant, YaRN Planner, GGUF Bridge, Launch Flags, Inspect config…
✓ “¿Me creo este número?” — Contamination, Drift, Arena CI, Saturation.
⚙️ “Montar bien una eval” — Chat-template Sniffer, Diagnose CLI, JSON CoT, PEFT Lint, Cache Diff, Spec-Decode, Token Tax.
🆚 “Comparar modelos” — Compare (2-3 modelos, misma receta) y el diagrama de fases interactivo (el atlas en vivo).
📋 “Manual / a mi aire” — Pick recipe (una X-* concreta) y Ask (pregunta en lenguaje natural; la resuelve un LLM pequeño in-browser).

Destacado reciente — 💾 Fit Check (“¿me cabe?”): modelo + precisión + GPU + contexto → el presupuesto completo de VRAM (pesos + caché KV + scratch), por qué no cabe si no cabe (¿pesos o KV?), el contexto máximo que sí cabe, y el rescate más barato. Responde la pregunta más repetida de los foros antes de descargar nada — y enseña de paso la lección del Cap. 21: a contexto largo, la caché KV puede pesar tanto como el modelo.

48.7 Demos guiadas y tu idioma

Cada modo lleva un botón 🎬 Demo: una simulación guiada que teclea, pulsa y narra paso a paso, y termina con una tarjeta de “qué acabas de aprender”. Enlazables: ?demo=fitcheck, ?demo=profile, ?demo=yarn… — útiles para compartir o enseñar.
Cuatro idiomas de punta a punta (EN/ES/FR/ZH): desde la v0.12 no solo los menús — también las demos, los veredictos de las recetas y sus explicaciones siguen el idioma del navegador.

48.8 El Anti-Bullshit Pack

Diagnósticos que atacan el “humo” de las fichas de modelo: Context Unmasker (contexto largo real vs anunciado), Chat-template Sniffer, Quant-regime Classifier, Multilingual Tokenizer Tax (tokeniza texto real en 6 tokenizadores → cuánto “cuesta” tu idioma), Contamination Prior, LongScore (RULER+HELMET), PEFT Anti-Pattern, Spec-Decode, y extensión: planificador YaRN/RoPE, GGUF Bridge, Launch-Flag Generator.

48.9 Las recetas (8 core)

Receta	Para qué	Cap.
X-1	custom vs API	25, 36
X-2	viabilidad de contexto largo	19
X-3	pre-flight de presupuesto	25
X-5	hardware	36
X-19	compresión de KV (soft-decay/cutoff)	20
X-21	huella de entrenamiento en γ (γ_train) — retirada como predictor: ν no está identificada con los datos actuales (Capítulo 39)	15
X-22	invariante cómputo-contexto	34
X-23	detector de fase de cabezas de inducción	24, 30

48.10 Cómo leer la salida: la TAF Card

El resultado se resume en una TAF Card con veredictos ✅ / ⚠ / ❌ por dimensión (contexto, cuantización, plantilla, régimen). Y hay un dashboard de falsación (F1-F23): no solo te da números, sino que somete las afirmaciones a prueba —la misma filosofía del Cap. 38—.

Un flujo típico: Profile (pega el id) → lee el veredicto de la TAF Card → si algo sale ⚠/❌, abre el diagnóstico concreto (p. ej. Context Unmasker o Quant-regime) → usa la receta correspondiente (X-2 contexto, X-19 KV) para decidir.

48.11 Puntuación de evidencias: puntos, no probabilidades

X-2 y Memory Reality muestran Puntuación de evidencias: N / 100. Es una heurística de los factores enumerados, no una probabilidad de acierto, una exactitud medida ni un benchmark de calidad de la tarea. Incluso 100/100 solo cubre esa lista: no demuestra que la predicción vaya a cumplirse.

Cada factor aporta 1 si tiene apoyo, 0,5 si es parcial y 0 si falta o está fuera del régimen indicado. La media ponderada se multiplica por 100 y se redondea. Los pesos son 1 salvo indicación; los niveles alto (≥ 80), medio (≥ 55) y bajo son decisiones heurísticas, no umbrales calibrados con una tasa de acierto. La interfaz permite desplegar el método y cambia de idioma con el resultado.

Una γ aportada no es un benchmark independiente de calidad. Estar dentro del régimen de una fórmula tampoco demuestra validación empírica. Como las listas varían entre modos, no se deben usar sus puntuaciones para ordenar la calidad de modelos. La puntuación no ejecuta inferencia ni recoge nuevas mediciones.

Predicción frente a realidad compara registros y condiciones del protocolo; no muestra esta puntuación. R² sigue siendo bondad de ajuste, no una probabilidad de éxito (véase R4). Los campos JSON históricos confidence y pct se conservan por compatibilidad, junto a score, max_score: 100, kind: "evidence_checklist", calibrated: false y scope: "listed_factors_only".

48.12 Verificación (los recibos)

Pyodide para las matemáticas (deterministas), WebLLM para el lenguaje natural, transformers.js para el tokenizador.
Verificación Lean+Mathlib: 15 identidades probadas formalmente (github.com/karlesmarin/lean-taf).
Panel de 23 modelos abierto (github.com/karlesmarin/tafagent-registry). Es el registro de la herramienta (config + predicciones contrastadas), no el atlas γ del Cap. 16 —ese son 42 modelos y 79 medidas de atención real—.

⚠ Honesto — qué es predicción y qué es medida

Muchas salidas (γ_Padé, horizonte estimado, KV a longitud L) son predicciones desde la config —rápidas y útiles para decidir antes de gastar GPU—, no medidas sobre la atención real. Cuando tengas el modelo, contrasta con γ_observado (medido) y con tu propia medición (R4). Y recuerda los límites del libro: D_f y el headroom de contexto son 🟡 reglas no validadas del todo (R1).

Siguiente referencia (R6): las soluciones orientativas de los ejercicios de cada capítulo.

Estudios y demos: Float32 · mHC. Cálculos ilustrativos opcionales, sin inferencia ni descarga de pesos.