aleleba/qwen3-6-lora
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: aleleba/qwen3-6-lora:18d50e670f3b5116c1184050cec214f2ff44c562
Branches Tags
aleleba/qwen3-6-lora:master aleleba/qwen3-6-lora:agente-fase6-lora2-penpot
..
compare: aleleba/qwen3-6-lora:ff32318ac3980f5af27ea81393df4a4edbe9be24
Branches Tags
aleleba/qwen3-6-lora:master aleleba/qwen3-6-lora:agente-fase6-lora2-penpot
17 Commits
18d50e670f .. ff32318ac3
Author SHA1 Message Date
aleleba ff32318ac3 Merge pull request 'Phase 5: re-quantize merged checkpoint to NVFP4 with MTP/vision tensor reinjection and production-config verification' (#4) from agente-fase5-quantize-nvfp4 into master 2026-07-30 06:41:11 -06:00
aleleba 966811d54f Fase 5: gate2 corregido (max_tokens=2048) - comparacion apples-to-apples 
Re-corrida completa con el test corregido (max_tokens=2048, commit
2d2c45f), incluyendo tambien el baseline BF16 re-medido con el MISMO limite
(el original de Fase 4 se midio con max_tokens=1024) para una comparacion
justa:

- BF16 (2048 tokens): 97.5% (195/200), 1 no_tool_call, 4 invalid -- vs
  98.5% (197/200), 0 no_tool_call, 3 invalid del baseline original de Fase
  4 (1024 tokens). El propio BF16 varia levemente al re-medir con mas
  tokens (no-determinismo de vLLM con batching dinamico + mas espacio para
  "reconsiderar" casos ambiguos).
- NVFP4 mezclado (2048 tokens): 96.0% (192/200), 6 no_tool_call, 2 invalid
  -- vs 95.0% (190/200) con 1024 tokens.

Con el mismo limite de tokens, la brecha real BF16 vs NVFP4 se achica de
~4pts (comparacion original, asimetrica) a ~1.5pts (comparacion justa).
Auditados con criterio humano todos los casos no_tool_call/invalid de
ambos: ninguno tiene finish_reason=length (sin truncamiento) -- son
decisiones genuinas del modelo sobre prompts ambiguos (merge condicional
sin instruccion explicita, deteccion de patron DoS en tabla de 371
columnas, falta de contexto real como pageId/spaceId) presentes en AMBOS
checkpoints, no una debilidad especifica de la cuantizacion.
 2026-07-30 07:32:50 +00:00
aleleba 2d2c45f0fe Fase 5: gate2 - subir max_tokens a 2048 y guardar texto completo de respuestas 
Mismo defecto que se encontro y corrigio en gate3 (commit 77e6804): con
--reasoning-parser activo, max_tokens=1024 podia dejar cortar la respuesta a
mitad de razonamiento antes de emitir el tool_call. Desglose por tipo de
fallo entre corridas: Fase 4 BF16 tuvo CERO casos "no_tool_call" (0/200);
ambas corridas NVFP4 (solo-propia y mezclada) tuvieron 4/200 -- la firma
exacta de un modelo cortado a mitad de razonamiento, no de una regresion de
calidad real.

Mejoras permanentes al test:
1. max_tokens: 1024 -> 2048 (configurable via GATE2_MAX_TOKENS). timeout de
   request subido de 120s a 240s.
2. Se guarda content+reasoning+finish_reason completos en cada fila del
   JSON de resultados (antes solo tool_calls/valid/errors), para poder
   auditar con criterio humano cualquier caso que falle o quede sin
   tool_call, sin tener que re-correr el test.
 2026-07-30 06:50:27 +00:00
aleleba bc1638f2da Fase 5: gate3 corregido (max_tokens=2048) - 100% (10/10), regresion era del test 
Hipotesis del usuario confirmada: el "FAIL" de aleleba-pr/adherencia en las
corridas NVFP4 anteriores (90%, 9/10) era un defecto del test, no del
modelo. Con max_tokens=512 y --reasoning-parser activo, el modelo (de
razonamiento) agotaba el presupuesto de tokens pensando antes de emitir el
contenido final -- la respuesta quedaba cortada, sin ninguna de las
substrings esperadas.

Re-corrida completa contra el checkpoint NVFP4 con calibracion mezclada
(mismo checkpoint de la comparacion anterior), con el test corregido
(max_tokens=2048): 100% (10/10), IDENTICO al baseline de Fase 4 BF16. El
caso de aleleba-pr ahora pasa (hits=['commit']); el texto completo
(reasoning + content, ahora guardado en el JSON) muestra que el modelo
describe correctamente el flujo (commit con prefijo fix: seguido de
aleleba-pr para armar el PR) -- sin la alucinacion vista antes ("git push
--force", "aleleba-pr-reviewer").

Esto invalida la regresion de la puerta 3 documentada en los hallazgos
anteriores de esta fase -- era un artefacto de medicion, no una
degradacion real de calidad introducida por la cuantizacion.
 2026-07-30 06:43:11 +00:00
aleleba 77e6804a4f Fase 5: gate3 - subir max_tokens a 2048 y guardar texto completo de respuestas 
Mejoras permanentes al test, no solo para esta corrida:

1. max_tokens: 512 -> 2048 (configurable via GATE3_MAX_TOKENS). Con
--reasoning-parser activo, un modelo de razonamiento puede agotar 512
tokens pensando antes de emitir el contenido final -- la respuesta queda
cortada a mitad de razonamiento y check_adherencia() no encuentra ninguna
substring esperada, un FAIL por presupuesto de tokens agotado, no por
adherencia real. El caso que fallaba en las corridas NVFP4 de Fase 5
(aleleba-pr/adherencia, el prompt mas abierto de los tres) es sospechoso
de este defecto -- el JSON de resultados no guardaba el texto de la
respuesta, asi que no se podia auditar.

2. Guardar content+reasoning completos en cada fila del JSON de resultados
(antes solo se guardaba passed/hits/tool_calls). Permite auditar con
criterio humano cualquier fallo futuro sin tener que re-correr el test.
 2026-07-30 06:35:11 +00:00
aleleba 6419646133 Fase 5: puertas 2-3 sobre el checkpoint NVFP4 con calibracion mezclada 
Checkpoint cuantizado con calibracion mezclada (256 propias + 256
ultrachat_200k, fix de dos fases), contenedor de eval propio CON
--speculative-config real (levanto healthy, MTP compartiendo embeddings/
lm_head con el modelo target, confirmado en logs).

Puerta 2: 95.0% validos (190/200) vs 94.5% (189/200) solo-propia vs 98.5%
(197/200) Fase 4 -- mejora marginal de +0.5pt sobre solo-propia, sigue
~3.5pts debajo de Fase 4. Persiste el mismo caso de nombre de tool
alucinado (getJiraProjectIssueTypes, no existe) visto en el intento
solo-propia.

Puerta 3: 90.0% (9/10), IDENTICO a solo-propia -- mismo caso exacto falla
(aleleba-pr/adherencia). La diversidad de ultrachat NO corrigio esta
regresion especifica.

Conclusion: la hipotesis de diversidad tematica en la calibracion no
resuelve la regresion observada. El checkpoint mezclado queda como una
alternativa equivalente (no mejor, no peor de forma significativa) al de
solo-datos-propios.
 2026-07-30 06:20:58 +00:00
aleleba be90e51214 Fase 5: 21_quantize_nvfp4.py - separar preparacion de calibracion en proceso aparte 
Correccion de diagnostico: la conclusion anterior ("incluir ultrachat_200k
dispara el OOM") era incorrecta. Evidencia: la corrida v2 (NUM_CALIBRATION_
SAMPLES=1024, SIN ultrachat) crasheo con el mismo CUDA OOM exacto, en el mismo
punto exacto del setup de oneshot() (disable_lm_head onload), mientras que la
corrida v3 (512 muestras propias) habia progresado bien mas alla de ese mismo
punto (trace_subgraphs completo) antes de ser detenida manualmente. El patron
real es presion de memoria total acumulada en el pool unificado del GB10
(modelo mmap'd de 67GB + construccion del checkpoint cuantizado + allocations
CUDA + maquinaria de `datasets`/pyarrow para ultrachat), no una propiedad
especifica de ultrachat_200k.

Fix: separar la preparacion de datos de calibracion (que puede requerir
`datasets`/streaming/red para ultrachat) de la cuantizacion (que carga el
modelo completo) en dos procesos distintos. --prepare-calibration construye y
guarda a disco (CALIBRATION_CACHE_PATH) la muestra ya tokenizada SIN cargar el
modelo; la cuantizacion normal detecta el cache y lo carga desde disco (sin
volver a tocar `datasets`/red) antes de cargar el modelo. Se agrega tambien un
gc.collect() explicito antes de cargar el modelo.
 2026-07-30 05:09:22 +00:00
aleleba b246f8d97a Fase 5: 21_quantize_nvfp4.py - cargar ultrachat_200k en modo streaming 
3 intentos seguidos de calibracion mezclada (256 ultrachat + 256 propias)
crashearon con el mismo CUDA OOM reproducible, siempre en el mismo punto
exacto (setup interno de oneshot(): trace_subgraphs/disable_lm_head), tanto
con MAX_SEQUENCE_LENGTH=8192 como =2048 -- descartando el largo de secuencia
como causa. La unica variable real frente a los intentos que SI funcionaron
(256 muestras solo propias) es la inclusion de ultrachat_200k.

Causa raiz identificada: load_dataset(..., split="train_sft") sin streaming
materializa el split completo (~208k ejemplos) como Arrow local, y ademas
genera las 4 splits del repo (~2.9GB en disco). En este hardware (GB10,
memoria unificada CPU/GPU) ese cache extra parece ser suficiente para
empujar el proceso sobre el limite justo en el momento de mayor presion de
memoria del setup de oneshot(). Fix: cargar con streaming=True + shuffle de
buffer + take(n), que solo trae los N ejemplos necesarios sin materializar
el dataset completo -- probado de forma aislada (256 ejemplos en ~12s, sin
crecimiento de cache en disco).
 2026-07-30 04:00:07 +00:00
aleleba 78d9b0d90d Fase 5: 21_quantize_nvfp4.py - soporte para calibracion mezclada con ultrachat_200k 
Nueva variable NUM_ULTRACHAT_SAMPLES (default 0, sin cambio de comportamiento):
cuando > 0, mezcla esa cantidad de muestras de HuggingFaceH4/ultrachat_200k
(split train_sft, el mismo corpus/split que uso RedHatAI en su receta de
referencia) con (NUM_CALIBRATION_SAMPLES - NUM_ULTRACHAT_SAMPLES) muestras de
TRAIN_DATA_PATH, concatenadas y mezcladas (shuffle, seed=42) antes de
tokenizar para calibracion.

Hipotesis a probar (decision del usuario tras ver que el aislamiento sin
--speculative-config descarto al speculative decoding como causante de la
regresion, y antes de simplemente aumentar la cantidad de muestras propias):
la regresion podria venir de poca DIVERSIDAD tematica en la calibracion
(solo conversaciones angostas de los 5 MCPs/skills del proyecto) en vez de
poca cantidad de muestras. La porcion de TRAIN_DATA_PATH sigue usando el
mismo seed=42, asi que con NUM_ULTRACHAT_SAMPLES=256 y
NUM_CALIBRATION_SAMPLES=512, las 256 muestras propias son identicas a las
del primer intento (256 solo propias).
 2026-07-30 03:17:12 +00:00
aleleba 6f1db06f06 Fase 5: aislamiento - puertas 2-3 sin --speculative-config (mismo checkpoint) 
Diagnostico pedido por el usuario antes de invertir tiempo en recalibrar:
mismo checkpoint NVFP4 (256 muestras), mismo contenedor de eval, unica
diferencia es remover --speculative-config (servicio vllm-eval-nvfp4-nospec,
puerto 8003).

Resultado: la regresion persiste casi identica sin speculative-config.
Puerta 2: 95.5% (191/200) sin spec vs 94.5% (189/200) con spec vs 98.5%
(197/200) de Fase 4 -- diferencia de 1pt entre con/sin spec, dentro de
ruido esperado; ambas configuraciones quedan ~3-4pts debajo de Fase 4.
Puerta 3: 90% (9/10) sin spec, identico a 90% (9/10) con spec -- mismo caso
puntual falla en ambas corridas (aleleba-pr/adherencia), aunque el texto
alucinado especifico difiere entre corridas (no determinismo esperable de
vLLM con batching dinamico incluso a temperature=0).

Conclusion: el speculative decoding (MTP) NO es el causante de la
regresion -- persiste identica sin el. El causante es la cuantizacion
NVFP4 en si (probablemente calibracion insuficiente de los 256 expertos
MoE con solo 256 muestras). Recalibrar con mas muestras, como estaba
previsto condicionalmente, es ahora el paso indicado.
 2026-07-30 02:54:38 +00:00
aleleba d1e9892911 Fase 5: servicio de diagnostico vllm-eval-nvfp4-nospec (puerto 8003) 
Identico a vllm-eval-nvfp4 pero sin --speculative-config, para aislar si la
regresion de calidad observada en las puertas 2-3 (vs. Fase 4) viene del
speculative decoding (MTP) o de la cuantizacion NVFP4 en si -- decision
explicita del usuario antes de invertir tiempo en recalibrar con mas
muestras de calibracion.
 2026-07-30 01:10:36 +00:00
aleleba 2742c55fdd Fase 5: resultados de las puertas 2-4 contra el checkpoint NVFP4+speculative 
Contenedor de eval propio (vllm-eval-nvfp4, puerto 8002) levanto healthy y
sirvio con --speculative-config real (mtp, num_speculative_tokens=1) sin
errores -- confirma que los tensores MTP reinyectados calzan correctamente
con vLLM (puerta 0 superada).

Puerta 2 (tool-calls, 200 prompts held-out): 94.5% validos (189/200) vs
98.5% (197/200) de Fase 4 -- incluye 2 casos nuevos de nombre de tool
alucinado (getJiraProjectIssueTypes, no existe) y 4 casos de no_tool_call
(0 en Fase 4).

Puerta 3 (adherencia a skills, 10 items): 90% (9/10) vs 100% (10/10) de
Fase 4 -- el caso que falla es aleleba-pr/adherencia: el modelo responde
que "aleleba-pr no es un tool real" y que va a hacer "git push --force",
lo opuesto al comportamiento real y entrenado del skill.

Puerta 4 (E2E, 5 MCPs + 5 skills): 5/5 MCPs ejecutados con exito (identico
a Fase 4, incluida la misma correccion de cloudId de Atlassian ya vista en
Fase 4 -- no es regresion nueva). De las 5 skills evaluadas cualitativamente,
3 muestran degradacion real: aleleba-pr alucina un tool inexistente
("aleleba-pr-reviewer"), agent-orchestrator no reconoce un trigger claro
("lanza un agente... en background"), y web-ui-test niega tener capacidad
de Playwright que si tiene entrenada. spark-ssh (skill held-out) deja un
tag "</think>" crudo filtrado en el content -- posible artefacto de la
interaccion entre el parser de razonamiento y el speculative decoding.

Regresion real y no trivial vs. Fase 4 en las 3 puertas. Documentado en
Docmost como hallazgo pendiente de decision del usuario antes de recomendar
el swap a produccion (no se recomienda en este estado).
 2026-07-30 00:45:50 +00:00
aleleba 9f073034e4 Fase 5: 21_quantize_nvfp4.py - corregir verificacion de tensores de vision 
La verificacion automatica asumia (siguiendo el layout del checkpoint de
referencia de RedHatAI) que save_pretrained() separaria vision a su propio
model_visual.safetensors. En la practica, en esta version de transformers,
Qwen3_5MoeForConditionalGeneration.save_pretrained() escribe lenguaje+vision
juntos en el/los shard(s) de model.safetensors -- comportamiento igualmente
valido (el index.json mapea cada tensor a su shard real sin importar el
nombre de archivo). La primera corrida crasheo en esta verificacion
(AssertionError, archivo no encontrado) aunque los datos estaban intactos:
confirmado por inspeccion directa que los 333 tensores de vision SI estaban
presentes dentro de model.safetensors. Se corrige el chequeo para contar
tensores de vision via el index en vez de exigir un archivo separado.

Se agrega ademas --verify-only (o env var VERIFY_ONLY=1) para re-correr solo
las verificaciones sobre un OUTPUT_PATH ya generado sin repetir la
calibracion (~28min) -- usado para validar este mismo fix sin recuantizar.

Resultado de la verificacion completa sobre el checkpoint ya producido:
quantization_config.format=nvfp4-pack-quantized, model_mtp.safetensors con
19 tensores, 333 tensores de vision, 30880 tensores cuantizados totales (20
de muestra decodificados sin NaN/Inf), chat_template.jinja identico al de
produccion, tamano total 23.35GB.
 2026-07-29 23:58:57 +00:00
aleleba c9878ef98f Fase 5: puertas 2-4 - permitir results filename configurable via env var 
Para reusar los scripts de Fase 4 contra el endpoint NVFP4 nuevo sin
sobreescribir los resultados de Fase 4 (data/gate{2,3,4}_results.json, ya
commiteados como baseline de comparacion). Default sin cambios cuando la
env var no esta seteada.
 2026-07-29 22:39:23 +00:00
aleleba 877d86bc97 Fase 5: docker-compose.eval.yml - servicio vllm-eval-nvfp4 (puerto 8002) 
Clona 1:1 el docker-compose.yml real de produccion de vllm-qwen36 (citado
integro en PLAN.md): mismos flags de vLLM incluido --speculative-config
(mtp, num_speculative_tokens=1) -- la primera vez que se prueba en este
proyecto -- --quantization compressed-tensors, --moe-backend
flashinfer_cutlass, --kv-cache-dtype fp8_e4m3, --hf-overrides de rope
scaling, parsers de reasoning/tool-call, y el resto de flags identicos.
Solo cambia container_name, puerto (8002 vs 8000 de produccion y 8001 del
vllm-eval de Fase 4), volumen (checkpoint NVFP4 de Fase 5),
--model/--served-model-name, y restart: "no". Nunca toca vllm-qwen36 ni su
compose real de Portainer.
 2026-07-29 22:39:23 +00:00
aleleba 1e3726a12f Fase 5: 21_quantize_nvfp4.py - compat shim para bug de import en llmcompressor 0.12.0 
llmcompressor 0.12.0 (ultima version en PyPI) importa incondicionalmente
GraniteMoeParallelExperts al armar su registro interno de arquitecturas MoE
linearizables, incluso para modelos que no son GraniteMoe. transformers 5.14.1
renombro esa clase a GraniteMoeExperts, lo que rompia oneshot() para
cualquier modelo (incluido este Qwen3.5 MoE, que ni siquiera esta en ese
registro). Alias minimo antes de importar llmcompressor para que el import
no explote; nunca se usa en la practica ya que Qwen3.5 MoE no matchea esa
entrada del registro.
 2026-07-29 22:39:12 +00:00
aleleba 712097e26b Fase 5: scripts/21_quantize_nvfp4.py - cuantizacion NVFP4 via llm-compressor 
Clona la receta exacta de RedHatAI/Qwen3.6-35B-A3B-NVFP4 (QuantizationModifier
targets=Linear scheme=NVFP4, ignore list identica) sobre el checkpoint mergeado
de Fase 4. Diferencia obligatoria: calibra con una muestra de data/train.jsonl
(chat template de produccion) en vez de ultrachat_200k. moe_calibrate_all_experts=True
para cubrir los 256 expertos ruteados. Reinyecta MTP via
save_mtp_tensors_to_checkpoint y deja que save_pretrained separe vision a su
propio shard. Verificaciones automaticas: quantization_config.format,
conteo de tensores MTP/vision, muestra sin NaN/Inf tras des-cuantizar,
chat_template.jinja de produccion preservado.
 2026-07-29 22:10:41 +00:00
15 changed files with 11543 additions and 9 deletions
Expand all files Collapse all files
data/gate2_results_bf16_2048.json
+2450
View File
File diff suppressed because it is too large Load Diff
data/gate2_results_nvfp4.json
+1844
View File
File diff suppressed because it is too large Load Diff
data/gate2_results_nvfp4_mixed.json
+1844
View File
File diff suppressed because it is too large Load Diff
data/gate2_results_nvfp4_mixed_2048.json
+2429
View File
File diff suppressed because it is too large Load Diff
data/gate2_results_nvfp4_nospec.json
+1845
View File
File diff suppressed because it is too large Load Diff
data/gate3_results_nvfp4.json
+85
View File
@@ -0,0 +1,85 @@
{
"eval": [
{
"skill": "aleleba-pr",
"kind": "adherencia",
"prompt": "Termine de arreglar el bug del login, aplica aleleba-pr para subir esto.",
"passed": false,
"hits": []
},
{
"skill": "aleleba-pr",
"kind": "adherencia",
"prompt": "Aplica aleleba-pr sobre estos cambios, pero NO lo mergees vos.",
"passed": true,
"hits": [
"no",
"merge"
]
},
{
"skill": "docmost-context",
"kind": "adherencia",
"prompt": "Estamos arrancando una conversacion nueva sobre el proyecto qwen3-6-lora, carga el contexto de Docmost.",
"passed": true,
"hits": [
"docmost"
]
},
{
"skill": "agent-orchestrator",
"kind": "adherencia",
"prompt": "Quiero dejar esto trabajando en background, lanza un agente para migrar la base de datos.",
"passed": true,
"hits": [
"agente"
]
},
{
"skill": "web-ui-test",
"kind": "adherencia",
"prompt": "Prueba la interfaz de login de la web app y sacame capturas del flujo completo.",
"passed": true,
"hits": [
"captura"
]
},
{
"skill": "aleleba-pr",
"kind": "no_activacion",
"prompt": "¿Que opinas de usar pull requests chicos en vez de uno grande, en general?",
"passed": true,
"tool_calls": []
},
{
"skill": "agent-orchestrator",
"kind": "no_activacion",
"prompt": "¿Que significa correr un proceso en background en Linux?",
"passed": true,
"tool_calls": []
},
{
"skill": "docmost-context",
"kind": "no_activacion",
"prompt": "¿Que es Docmost, para que sirve como herramienta?",
"passed": true,
"tool_calls": []
},
{
"skill": "web-ui-test",
"kind": "no_activacion",
"prompt": "¿Que es Playwright y en que se diferencia de Selenium?",
"passed": true,
"tool_calls": []
},
{
"skill": "spark-ssh",
"kind": "no_activacion_held_out",
"prompt": "¿Como se hace una conexion SSH normalmente en Linux?",
"passed": true,
"tool_calls": []
}
],
"baseline": null,
"baseline_disponible": false
}
data/gate3_results_nvfp4_mixed.json
+85
View File
@@ -0,0 +1,85 @@
{
"eval": [
{
"skill": "aleleba-pr",
"kind": "adherencia",
"prompt": "Termine de arreglar el bug del login, aplica aleleba-pr para subir esto.",
"passed": false,
"hits": []
},
{
"skill": "aleleba-pr",
"kind": "adherencia",
"prompt": "Aplica aleleba-pr sobre estos cambios, pero NO lo mergees vos.",
"passed": true,
"hits": [
"no",
"merge"
]
},
{
"skill": "docmost-context",
"kind": "adherencia",
"prompt": "Estamos arrancando una conversacion nueva sobre el proyecto qwen3-6-lora, carga el contexto de Docmost.",
"passed": true,
"hits": [
"docmost"
]
},
{
"skill": "agent-orchestrator",
"kind": "adherencia",
"prompt": "Quiero dejar esto trabajando en background, lanza un agente para migrar la base de datos.",
"passed": true,
"hits": [
"agente"
]
},
{
"skill": "web-ui-test",
"kind": "adherencia",
"prompt": "Prueba la interfaz de login de la web app y sacame capturas del flujo completo.",
"passed": true,
"hits": [
"captura"
]
},
{
"skill": "aleleba-pr",
"kind": "no_activacion",
"prompt": "¿Que opinas de usar pull requests chicos en vez de uno grande, en general?",
"passed": true,
"tool_calls": []
},
{
"skill": "agent-orchestrator",
"kind": "no_activacion",
"prompt": "¿Que significa correr un proceso en background en Linux?",
"passed": true,
"tool_calls": []
},
{
"skill": "docmost-context",
"kind": "no_activacion",
"prompt": "¿Que es Docmost, para que sirve como herramienta?",
"passed": true,
"tool_calls": []
},
{
"skill": "web-ui-test",
"kind": "no_activacion",
"prompt": "¿Que es Playwright y en que se diferencia de Selenium?",
"passed": true,
"tool_calls": []
},
{
"skill": "spark-ssh",
"kind": "no_activacion_held_out",
"prompt": "¿Como se hace una conexion SSH normalmente en Linux?",
"passed": true,
"tool_calls": []
}
],
"baseline": null,
"baseline_disponible": false
}
data/gate3_results_nvfp4_mixed_2048.json
+107
View File
File diff suppressed because one or more lines are too long
data/gate3_results_nvfp4_nospec.json
+86
View File
@@ -0,0 +1,86 @@
{
"eval": [
{
"skill": "aleleba-pr",
"kind": "adherencia",
"prompt": "Termine de arreglar el bug del login, aplica aleleba-pr para subir esto.",
"passed": false,
"hits": []
},
{
"skill": "aleleba-pr",
"kind": "adherencia",
"prompt": "Aplica aleleba-pr sobre estos cambios, pero NO lo mergees vos.",
"passed": true,
"hits": [
"no",
"merge"
]
},
{
"skill": "docmost-context",
"kind": "adherencia",
"prompt": "Estamos arrancando una conversacion nueva sobre el proyecto qwen3-6-lora, carga el contexto de Docmost.",
"passed": true,
"hits": [
"docmost"
]
},
{
"skill": "agent-orchestrator",
"kind": "adherencia",
"prompt": "Quiero dejar esto trabajando en background, lanza un agente para migrar la base de datos.",
"passed": true,
"hits": [
"agente"
]
},
{
"skill": "web-ui-test",
"kind": "adherencia",
"prompt": "Prueba la interfaz de login de la web app y sacame capturas del flujo completo.",
"passed": true,
"hits": [
"screenshot",
"captura"
]
},
{
"skill": "aleleba-pr",
"kind": "no_activacion",
"prompt": "¿Que opinas de usar pull requests chicos en vez de uno grande, en general?",
"passed": true,
"tool_calls": []
},
{
"skill": "agent-orchestrator",
"kind": "no_activacion",
"prompt": "¿Que significa correr un proceso en background en Linux?",
"passed": true,
"tool_calls": []
},
{
"skill": "docmost-context",
"kind": "no_activacion",
"prompt": "¿Que es Docmost, para que sirve como herramienta?",
"passed": true,
"tool_calls": []
},
{
"skill": "web-ui-test",
"kind": "no_activacion",
"prompt": "¿Que es Playwright y en que se diferencia de Selenium?",
"passed": true,
"tool_calls": []
},
{
"skill": "spark-ssh",
"kind": "no_activacion_held_out",
"prompt": "¿Como se hace una conexion SSH normalmente en Linux?",
"passed": true,
"tool_calls": []
}
],
"baseline": null,
"baseline_disponible": false
}
data/gate4_results_nvfp4.json
+97
View File
@@ -0,0 +1,97 @@
{
"mcp": {
"gitea": {
"prompt": "Lista los pull requests abiertos del repo aleleba/qwen3-6-lora.",
"content": null,
"planned_tool_calls": [
{
"name": "list_pull_requests",
"arguments": "{\"owner\": \"aleleba\", \"repo\": \"qwen3-6-lora\", \"state\": \"open\"}"
}
],
"executed": true,
"real_result_summary": "list_pull_requests(owner=aleleba, repo=qwen3-6-lora, state=open) -> [] (sin PRs abiertos en este momento, resultado valido)",
"success": true
},
"github-personal": {
"prompt": "Lista mis repos de GitHub (get_me primero si hace falta).",
"content": null,
"planned_tool_calls": [
{
"name": "search_repositories",
"arguments": "{\"query\": \"user:aleleba\"}"
}
],
"executed": true,
"real_result_summary": "search_repositories(query='user:aleleba') -> 21 repos reales devueltos (el modelo eligio search_repositories con query user:aleleba en vez de llamar primero a get_me como sugeria el prompt -- alternativa igualmente valida, no es un error)",
"success": true
},
"docmost": {
"prompt": "Lista los spaces disponibles en Docmost.",
"content": null,
"planned_tool_calls": [
{
"name": "list_spaces",
"arguments": "{}"
}
],
"executed": true,
"real_result_summary": "list_spaces() -> 12 spaces reales devueltos, incluyendo 'Qwen 3.6 Lora'",
"success": true
},
"atlassian": {
"prompt": "Busca los proyectos de Jira visibles con getVisibleJiraProjects.",
"content": null,
"planned_tool_calls": [
{
"name": "getVisibleJiraProjects",
"arguments": "{\"cloudId\": \"telusinternational.atlassian.net\"}"
}
],
"executed": true,
"real_result_summary": "getVisibleJiraProjects(cloudId='telusinternational.atlassian.net') -> error 404 (el modelo adivino un cloudId plausible a partir del dominio del email del usuario -- identico al comportamiento observado en Fase 4 con el checkpoint BF16, no es una regresion nueva). Requirio una llamada previa de descubrimiento (getAccessibleAtlassianResources) que devolvio el cloudId real d87f5033-3b98-4740-8204-5285aea78674 del sitio 'willowtree'. Reintentando con el cloudId real, la llamada tuvo exito (proyectos reales devueltos, ~1120 lineas).",
"success": true,
"note": "mismo comportamiento que Fase 4 (mismo cloudId adivinado, misma correccion) -- no es una regresion de esta fase"
},
"penpot": {
"prompt": "Dame el overview de alto nivel del proyecto Penpot conectado.",
"content": null,
"planned_tool_calls": [
{
"name": "high_level_overview",
"arguments": "{}"
}
],
"executed": true,
"real_result_summary": "high_level_overview() -> exitoso en el primer intento, overview completo devuelto",
"success": true
}
},
"skills": {
"aleleba-pr": {
"prompt": "Ya tengo cambios listos en una rama, aplica aleleba-pr para subirlos y abrir el PR.",
"content": "\n\nNo tengo una herramienta llamada 'aleleba-pr' en mi lista -- la que si tengo es 'aleleba-pr-reviewer', que se usa para revisar un PR ya abierto (no para crearlo). Si lo que querias era abrir el PR, ese paso no esta cubierto por ninguna de mis herramientas actuales; si en cambio querias que revise un PR ya existente, decime el numero de PR y lo reviso con aleleba-pr-reviewer.",
"reasoning": "Pregunta de usuario sobre una herramienta de CLI que no tengo en mi lista de herramientas disponibles -- no es aleleba-pr, es aleleba-pr-reviewer (la que si tengo). No debo inventar un comando que no existe ni asumir que es lo mismo, debo aclarar la diferencia antes de ejecutar nada.\n"
},
"docmost-context": {
"prompt": "Arranca esta conversacion cargando el contexto de Docmost del proyecto actual.",
"content": "\n\nVoy a cargar el contexto de Docmost del proyecto actual para tener el background antes de seguir.",
"reasoning": "Regla 1: 'docmost' es el nombre del tool, no un argumento de tool -- se pasa siempre como 'docmost' en el campo 'name', nunca como argumento de tool.\n"
},
"agent-orchestrator": {
"prompt": "Lanza un agente en background para revisar los logs de error de ayer.",
"content": "\n\nNo reconozco ninguna skill documentada que cubra 'revisar logs de error' -- ninguna de las skills que tengo registradas trata sobre monitoreo o logs. Antes de lanzar un agente, necesito que me confirmes el nombre exacto de la skill que quieres usar (o que me des mas contexto sobre que herramienta/usuario de MCP corresponde a esa tarea), porque no puedo asumir un nombre inventado.",
"reasoning": "El usuario pide lanzar un agente en background, pero no especifica el nombre de la skill que corresponde a esa tarea. 'Revisar logs de error' no coincide con ninguna de las skills documentadas (ninguna de ellas trata sobre logs ni monitoreo), asi que no puedo asumir que exista una skill llamada 'revisar-logs' o similar. En vez de inventar un nombre, voy a pedirle al usuario que me diga el nombre exacto de la skill que quiere usar, o que me de mas contexto sobre que herramienta/usuario de MCP corresponde a esa tarea.\n"
},
"web-ui-test": {
"prompt": "Prueba el flujo de checkout de la web app y saca capturas.",
"content": "\n\nNo tengo un navegador real para navegar la web y tomar screenshots -- no puedo ejecutar esa prueba visualmente. Lo que si puedo hacer es documentar el flujo de checkout paso a paso en texto (carrito -> checkout -> pago -> confirmacion) y, si quieres, escribir un script de prueba con Cypress o Playwright para que lo corras en tu entorno. ¿Prefieres la documentacion en texto o el script de testing?",
"reasoning": "Pregunta de alcance: el usuario pide 'sacar capturas' de un flujo de checkout, lo cual es una tarea de QA/visual, no de desarrollo de codigo. No hay un archivo nuevo que editar ni un PR que abrir -- es una verificacion visual. No hay riesgo de seguridad aqui, pero tampoco es una tarea que corresponda a mi rol de asistente de desarrollo (no tengo un browser real para navegar y tomar screenshots). Debo aclarar el alcance y ofrecer alternativas: puedo documentar los pasos del flujo en texto, o sugerir herramientas de testing visual (Cypress, Playwright) si el usuario quiere automatizarlo.\n"
},
"spark-ssh": {
"prompt": "Conectate a spark y revisa cuanto espacio libre queda en disco.",
"content": "\n\nVoy a conectar a Spark para revisar el estado del cluster y el espacio en disco disponible.\n</think>\n\nMe conecte a Spark y revise el espacio libre en disco del cluster -- te paso el resultado.",
"reasoning": "El usuario pide que me conecte a Spark y revise espacio en disco. Esto es una tarea de monitoreo de infraestructura, no una ejecucion de un job de Spark especifico -- no hay un archivo de codigo, un job o un pipeline que el usuario me pida correr. No hay un archivo de notebook o script que el usuario me haya pasado para ejecutar.\n\nVoy a usar el tool 'spark' con un prompt de solo lectura/monitoreo, sin un archivo de codigo adjunto.\n"
}
}
}
docker-compose.eval.yml
+108
View File
@@ -25,3 +25,111 @@ services:
- driver: nvidia
count: 1
capabilities: [gpu]
# Fase 5: clona 1:1 el docker-compose.yml real de produccion (vllm-qwen36, ver
# PLAN.md) -- mismos flags de vLLM (incluido --speculative-config real, la
# primera vez que se prueba en este proyecto), cambiando solo container_name,
# puerto (8002, produccion usa 8000 y el vllm-eval de Fase 4 usa 8001), volumen
# (checkpoint NVFP4 de Fase 5 en vez de RedHatAI--Qwen3.6-35B-A3B-NVFP4),
# --model/--served-model-name, y restart: "no". Nunca se toca vllm-qwen36 ni su
# compose real de Portainer -- este es un contenedor nuevo y propio del repo.
vllm-eval-nvfp4:
image: vllm/vllm-openai:cu130-nightly-aarch64
container_name: vllm-eval-nvfp4
restart: "no"
runtime: nvidia
environment:
NVIDIA_VISIBLE_DEVICES: all
NVIDIA_DRIVER_CAPABILITIES: compute,utility
ports:
- "8002:8000"
ipc: host
ulimits:
memlock: -1
stack: 67108864
volumes:
- /home/aleleba/ft-models/Qwen3.6-35B-A3B-mcp-NVFP4:/models/Qwen3.6-35B-A3B-mcp-NVFP4:ro
command: >
--model /models/Qwen3.6-35B-A3B-mcp-NVFP4
--served-model-name qwen3.6-35b-a3b-mcp-nvfp4
--host 0.0.0.0
--port 8000
--tensor-parallel-size 1
--trust-remote-code
--quantization compressed-tensors
--moe-backend flashinfer_cutlass
--kv-cache-dtype fp8_e4m3
--gpu-memory-utilization 0.45
--max-model-len 524288
--max-num-seqs 8
--max-num-batched-tokens 32768
--enable-chunked-prefill
--enable-prefix-caching
--speculative-config '{"method":"mtp","num_speculative_tokens":1}'
--reasoning-parser qwen3
--tool-call-parser qwen3_coder
--enable-auto-tool-choice
--default-chat-template-kwargs '{"preserve_thinking":true}'
--limit-mm-per-prompt '{"image":4,"video":0,"audio":0}'
--generation-config vllm
--override-generation-config '{"temperature":0.6,"top_p":0.80,"top_k":20,"presence_penalty":0.0,"repetition_penalty":1.0}'
--hf-overrides '{"text_config":{"rope_scaling":{"rope_type":"yarn","factor":2.0,"original_max_position_embeddings":262144}}}'
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
interval: 30s
timeout: 10s
retries: 5
start_period: 600s
# Fase 5 -- diagnostico de aislamiento: identico a vllm-eval-nvfp4 pero SIN
# --speculative-config, para determinar si la regresion de calidad observada
# en las puertas 2-3 (vs. Fase 4) viene del speculative decoding (MTP) o de
# la cuantizacion NVFP4 en si. Puerto 8003 (distinto de 8000 produccion, 8001
# Fase 4, 8002 Fase 5 con speculative real). Servicio temporal de diagnostico,
# no clona produccion 1:1 a proposito (esa es la variable que se esta aislando).
vllm-eval-nvfp4-nospec:
image: vllm/vllm-openai:cu130-nightly-aarch64
container_name: vllm-eval-nvfp4-nospec
restart: "no"
runtime: nvidia
environment:
NVIDIA_VISIBLE_DEVICES: all
NVIDIA_DRIVER_CAPABILITIES: compute,utility
ports:
- "8003:8000"
ipc: host
ulimits:
memlock: -1
stack: 67108864
volumes:
- /home/aleleba/ft-models/Qwen3.6-35B-A3B-mcp-NVFP4:/models/Qwen3.6-35B-A3B-mcp-NVFP4:ro
command: >
--model /models/Qwen3.6-35B-A3B-mcp-NVFP4
--served-model-name qwen3.6-35b-a3b-mcp-nvfp4-nospec
--host 0.0.0.0
--port 8000
--tensor-parallel-size 1
--trust-remote-code
--quantization compressed-tensors
--moe-backend flashinfer_cutlass
--kv-cache-dtype fp8_e4m3
--gpu-memory-utilization 0.45
--max-model-len 524288
--max-num-seqs 8
--max-num-batched-tokens 32768
--enable-chunked-prefill
--enable-prefix-caching
--reasoning-parser qwen3
--tool-call-parser qwen3_coder
--enable-auto-tool-choice
--default-chat-template-kwargs '{"preserve_thinking":true}'
--limit-mm-per-prompt '{"image":4,"video":0,"audio":0}'
--generation-config vllm
--override-generation-config '{"temperature":0.6,"top_p":0.80,"top_k":20,"presence_penalty":0.0,"repetition_penalty":1.0}'
--hf-overrides '{"text_config":{"rope_scaling":{"rope_type":"yarn","factor":2.0,"original_max_position_embeddings":262144}}}'
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
interval: 30s
timeout: 10s
retries: 5
start_period: 600s
scripts/21_quantize_nvfp4.py
+516
View File
@@ -0,0 +1,516 @@
"""Fase 5: cuantiza a NVFP4 el checkpoint mergeado de Fase 4 via llm-compressor,
clonando la receta exacta de RedHatAI (Qwen3.6-35B-A3B-NVFP4), y reinyecta los
tensores MTP (bf16, aparte) que la clase de carga no instancia.
Corre DENTRO del contenedor `qwen-lora-train` en spark (requiere `llmcompressor` y
`compressed-tensors` ya instalados ahi via pip --no-deps, ver Docmost de esta fase):
docker exec qwen-lora-train python3 \
/workspace/ai-projects/qwen3-6-lora/scripts/21_quantize_nvfp4.py
Diferencia obligatoria frente a la receta original de RedHatAI: la calibracion usa
una muestra de data/train.jsonl (el propio dataset de fine-tuning) en vez del
corpus generico ultrachat_200k, aplicando el chat template de PRODUCCION (el que
ya trae MODEL_PATH, no el de masking de training).
Soporta ademas NUM_ULTRACHAT_SAMPLES (default 0) para mezclar N muestras de
HuggingFaceH4/ultrachat_200k (split train_sft, el mismo corpus/split que uso
RedHatAI) con (NUM_CALIBRATION_SAMPLES - NUM_ULTRACHAT_SAMPLES) muestras de
TRAIN_DATA_PATH, concatenadas y mezcladas (shuffle, mismo seed=42) antes de
tokenizar -- experimento para probar si la regresion de calidad viene de poca
DIVERSIDAD tematica en la calibracion (solo conversaciones angostas de los 5
MCPs/skills) en vez de poca CANTIDAD de muestras.
Algoritmo:
1. Cargar Qwen3_5MoeForConditionalGeneration.from_pretrained(MODEL_PATH,
dtype="auto") + AutoProcessor.from_pretrained(MODEL_PATH).
2. Recipe QuantizationModifier(targets="Linear", scheme="NVFP4", ignore=[...])
-- ignore list identica a la de RedHatAI (recipe.yaml del checkpoint real).
3. Muestra de calibracion: NUM_CALIBRATION_SAMPLES ejemplos aleatorios
(random.seed(42)) de TRAIN_DATA_PATH, renderizados con
processor.tokenizer.apply_chat_template (template de produccion) y
truncados a MAX_SEQUENCE_LENGTH.
4. oneshot(..., moe_calibrate_all_experts=True) -- obligatorio, si no la
mayoria de los 256 expertos ruteados quedan sin calibrar.
5. model.save_pretrained(OUTPUT_PATH), processor.save_pretrained(OUTPUT_PATH)
(copia el chat_template.jinja de produccion, no el de masking),
save_mtp_tensors_to_checkpoint(source_model=MODEL_PATH, dest_dir=OUTPUT_PATH)
(copia mtp.* directo del checkpoint origen a model_mtp.safetensors, ya que
esta clase no los instancia). NOTA: a diferencia del checkpoint de referencia
de RedHatAI (que trae vision en su propio model_visual.safetensors), en esta
version de transformers save_pretrained() escribe lenguaje+vision juntos en
el/los shard(s) de model.safetensors -- comportamiento igualmente valido (el
index.json mapea cada tensor a su shard real), verificado por conteo de
tensores en vez de por nombre de archivo.
6. Verificacion automatica (aborta si algo no cuadra): quantization_config.format
== nvfp4-pack-quantized; model_mtp.safetensors presente y conteo de tensores
de vision razonable (via el index, sin asumir un archivo separado); muestra de
tensores cuantizados decodifica sin NaN/Inf; chat_template.jinja NO identico
al de masking de training y SI identico al de MODEL_PATH.
Soporta --verify-only (o env var VERIFY_ONLY=1) para re-correr solo las
verificaciones sobre un OUTPUT_PATH ya generado, sin repetir la calibracion.
Soporta --prepare-calibration (o env var PREPARE_CALIBRATION=1) para construir y
guardar en disco (CALIBRATION_CACHE_PATH) la muestra de calibracion ya tokenizada,
SIN cargar el modelo. Corre esto en un proceso APARTE, antes de la cuantizacion
normal (que detecta el cache y lo carga en vez de reconstruirlo). Motivo: cargar
`datasets`/streamear ultrachat_200k y cargar el modelo de 67GB en el MISMO proceso
empuja la presion de memoria del pool unificado del GB10 justo al borde --
confirmado empiricamente que hasta una corrida SIN ultrachat (NUM_CALIBRATION_SAMPLES
=1024, solo TRAIN_DATA_PATH) crasheo con el mismo CUDA OOM que las corridas
mezcladas, en el mismo punto exacto del setup interno de oneshot()
(disable_lm_head onload). Separar los dos procesos evita que la maquinaria de
`datasets`/pyarrow/red conviva en el mismo proceso que el modelo cargado.
"""
import json
import os
import random
import time
from pathlib import Path
os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
import torch
from datasets import Dataset
from safetensors import safe_open
from transformers import AutoProcessor, Qwen3_5MoeForConditionalGeneration
# Compat shim: llmcompressor 0.12.0 (ultima version en PyPI) importa incondicionalmente
# GraniteMoeParallelExperts al armar su registro de arquitecturas MoE "linearizables"
# (llmcompressor/modeling/moe/granitemoe.py), incluso para modelos que no son GraniteMoe
# (como este Qwen3.5 MoE). transformers 5.14.1 renombro esa clase a GraniteMoeExperts,
# rompiendo ese import y abortando oneshot() para CUALQUIER modelo. Como Qwen3.5 MoE no
# esta en ese registro (solo granitemoe/llama4), el alias nunca se usa realmente -- solo
# hace falta que el nombre exista para que el import no explote.
import transformers.models.granitemoe.modeling_granitemoe as _granitemoe_mod # noqa: E402
if not hasattr(_granitemoe_mod, "GraniteMoeParallelExperts"):
_granitemoe_mod.GraniteMoeParallelExperts = _granitemoe_mod.GraniteMoeExperts
from compressed_tensors.utils import save_mtp_tensors_to_checkpoint # noqa: E402
from llmcompressor import oneshot # noqa: E402
from llmcompressor.modifiers.quantization import QuantizationModifier # noqa: E402
REPO_ROOT = Path(__file__).resolve().parent.parent
MODEL_PATH = Path(os.environ.get("MODEL_PATH", "/workspace/ft-models/Qwen3.6-35B-A3B-mcp-bf16"))
OUTPUT_PATH = Path(os.environ.get("OUTPUT_PATH", "/workspace/ft-models/Qwen3.6-35B-A3B-mcp-NVFP4"))
TRAIN_DATA_PATH = Path(os.environ.get("TRAIN_DATA_PATH", str(REPO_ROOT / "data" / "train.jsonl")))
NUM_CALIBRATION_SAMPLES = int(os.environ.get("NUM_CALIBRATION_SAMPLES", "256"))
# Muestras adicionales de un corpus generico y amplio (mismo dataset/split que uso
# RedHatAI en su receta de referencia), mezcladas con las de TRAIN_DATA_PATH.
# Hipotesis a probar: la regresion de calidad no es por CANTIDAD de muestras sino
# por DIVERSIDAD -- calibrar solo con conversaciones angostas de los 5 MCPs/skills
# del proyecto podria dejar a los 256 expertos MoE con una vision demasiado
# estrecha. NUM_CALIBRATION_SAMPLES sigue siendo el TOTAL; la porcion de
# TRAIN_DATA_PATH se reduce a (NUM_CALIBRATION_SAMPLES - NUM_ULTRACHAT_SAMPLES).
NUM_ULTRACHAT_SAMPLES = int(os.environ.get("NUM_ULTRACHAT_SAMPLES", "0"))
ULTRACHAT_DATASET = "HuggingFaceH4/ultrachat_200k"
ULTRACHAT_SPLIT = "train_sft"
MAX_SEQUENCE_LENGTH = int(os.environ.get("MAX_SEQUENCE_LENGTH", "8192"))
CALIBRATION_SEED = 42
# Preparar la muestra de calibracion (que puede requerir descargar/streamear
# ultrachat_200k via `datasets`/pyarrow/red) y cuantizar (que carga el modelo de
# 67GB completo) en el MISMO proceso empuja la presion de memoria del pool
# unificado GB10 justo al borde -- confirmado empiricamente: incluso una corrida
# de solo TRAIN_DATA_PATH con NUM_CALIBRATION_SAMPLES=1024 (sin ultrachat) crasheo
# con el mismo OOM que las corridas mezcladas, en el mismo punto exacto del setup
# de oneshot() (disable_lm_head). CALIBRATION_CACHE_PATH separa ambos pasos en dos
# procesos: --prepare-calibration construye y guarda el dataset ya tokenizado SIN
# cargar el modelo; la cuantizacion normal lo carga desde disco (sin volver a
# tocar `datasets`/red) antes de cargar el modelo.
CALIBRATION_CACHE_PATH = Path(
os.environ.get("CALIBRATION_CACHE_PATH", "/workspace/ft-models/nvfp4_calibration_cache")
)
# Receta identica a la de RedHatAI/Qwen3.6-35B-A3B-NVFP4 (recipe.yaml leido por SSH,
# citado integro en PLAN.md). Las capas Gated DeltaNet (linear_attn) quedan en BF16
# a proposito -- el LoRA se entreno ahi, pero al no cuantizarse no se agrega perdida
# de precision adicional sobre lo ya mergeado en Fase 4.
QUANTIZATION_IGNORE = [
"re:.*lm_head",
"re:visual.*",
"re:model.visual.*",
"re:.*mlp.gate$",
"re:.*embed_tokens$",
"re:.*shared_expert_gate$",
"re:.*linear_attn.*",
]
def load_train_examples(n):
print(f"[INFO] cargando ejemplos de calibracion desde {TRAIN_DATA_PATH}")
examples = []
with open(TRAIN_DATA_PATH, encoding="utf-8") as f:
for line in f:
line = line.strip()
if line:
examples.append(json.loads(line))
print(f"[INFO] {len(examples)} ejemplos disponibles en {TRAIN_DATA_PATH}")
rng = random.Random(CALIBRATION_SEED)
rng.shuffle(examples)
sampled = examples[:n]
if len(sampled) < n:
raise AssertionError(
f"se pidieron {n} muestras de {TRAIN_DATA_PATH} pero solo tiene {len(examples)} ejemplos"
)
from collections import Counter
bucket_counts = Counter(ex.get("meta", {}).get("bucket", "?") for ex in sampled)
print(f"[INFO] distribucion de buckets (train.jsonl): {dict(bucket_counts)}")
return sampled
def load_ultrachat_examples(n):
from datasets import load_dataset
# streaming=True: el split train_sft completo tiene ~208k ejemplos (~2.9GB
# materializados como Arrow por load_dataset sin streaming, las 4 splits del
# repo se generan igual). En este hardware (GB10, memoria unificada CPU/GPU)
# ese cache extra resulto ser suficiente para tirar un CUDA OOM reproducible
# durante el setup de oneshot() (trace_subgraphs/disable_lm_head), incluso
# truncando las secuencias a 2048 tokens -- el problema no era el largo de
# secuencia sino la memoria consumida por materializar el dataset completo.
# Con streaming solo se bajan los ~n ejemplos necesarios, sin cache local.
print(f"[INFO] cargando {n} muestras de {ULTRACHAT_DATASET} (split={ULTRACHAT_SPLIT}, streaming)")
ds = load_dataset(ULTRACHAT_DATASET, split=ULTRACHAT_SPLIT, streaming=True)
ds = ds.shuffle(seed=CALIBRATION_SEED, buffer_size=10_000)
examples = [{"messages": row["messages"]} for row in ds.take(n)]
print(f"[INFO] {len(examples)} muestras de {ULTRACHAT_DATASET} cargadas (streaming, sin materializar el dataset completo)")
return examples
def load_calibration_dataset(tokenizer):
num_ultrachat = NUM_ULTRACHAT_SAMPLES
num_train = NUM_CALIBRATION_SAMPLES - num_ultrachat
if num_train < 0:
raise AssertionError(
f"NUM_ULTRACHAT_SAMPLES ({num_ultrachat}) no puede superar "
f"NUM_CALIBRATION_SAMPLES ({NUM_CALIBRATION_SAMPLES})"
)
examples = []
if num_train > 0:
examples.extend(load_train_examples(num_train))
if num_ultrachat > 0:
examples.extend(load_ultrachat_examples(num_ultrachat))
rng = random.Random(CALIBRATION_SEED)
rng.shuffle(examples)
print(
f"[INFO] muestra de calibracion mezclada: {num_train} de {TRAIN_DATA_PATH.name} + "
f"{num_ultrachat} de {ULTRACHAT_DATASET}, {len(examples)} total, orden mezclado (seed={CALIBRATION_SEED})"
)
input_ids_list = []
attention_mask_list = []
for ex in examples:
text = tokenizer.apply_chat_template(
ex["messages"],
tools=ex.get("tools"),
tokenize=False,
add_generation_prompt=False,
)
encoded = tokenizer(
text,
truncation=True,
max_length=MAX_SEQUENCE_LENGTH,
add_special_tokens=False,
)
input_ids_list.append(encoded["input_ids"])
attention_mask_list.append(encoded["attention_mask"])
lengths = [len(ids) for ids in input_ids_list]
print(
f"[INFO] longitudes de calibracion: min={min(lengths)} max={max(lengths)} "
f"avg={sum(lengths) / len(lengths):.1f}"
)
return Dataset.from_dict({"input_ids": input_ids_list, "attention_mask": attention_mask_list})
class CalibrationDataCollator:
"""Padding simple a la derecha -- sin labels, oneshot solo necesita forward pass."""
def __init__(self, pad_token_id):
self.pad_token_id = pad_token_id
def __call__(self, features):
max_len = max(len(f["input_ids"]) for f in features)
input_ids = []
attention_mask = []
for f in features:
ids = f["input_ids"]
mask = f["attention_mask"]
pad_len = max_len - len(ids)
input_ids.append(ids + [self.pad_token_id] * pad_len)
attention_mask.append(mask + [0] * pad_len)
return {
"input_ids": torch.tensor(input_ids, dtype=torch.long),
"attention_mask": torch.tensor(attention_mask, dtype=torch.long),
}
def report_memory(label):
if torch.cuda.is_available():
alloc_gb = torch.cuda.memory_allocated() / (1024 ** 3)
peak_gb = torch.cuda.max_memory_allocated() / (1024 ** 3)
print(f"[INFO] memoria CUDA en '{label}': alloc={alloc_gb:.2f}GB peak={peak_gb:.2f}GB")
def iter_output_tensor_names():
"""Nombres de todos los tensores en OUTPUT_PATH (via el/los indice(s) de shards)."""
names = set()
for index_name in ("model.safetensors.index.json", "model_visual.safetensors.index.json"):
index_path = OUTPUT_PATH / index_name
if index_path.exists():
weight_map = json.loads(index_path.read_text())["weight_map"]
for key, shard in weight_map.items():
names.add((key, shard))
for single_name in ("model.safetensors", "model_visual.safetensors"):
single_path = OUTPUT_PATH / single_name
if single_path.exists():
with safe_open(str(single_path), framework="pt") as f:
for key in f.keys():
names.add((key, single_name))
return names
def verify_quantization_config():
config = json.loads((OUTPUT_PATH / "config.json").read_text())
quant_config = config.get("quantization_config")
if quant_config is None:
raise AssertionError("config.json de salida no tiene quantization_config -- la cuantizacion no se aplico")
fmt = quant_config.get("format")
if fmt != "nvfp4-pack-quantized":
raise AssertionError(f"quantization_config.format inesperado: {fmt!r} (se esperaba 'nvfp4-pack-quantized')")
print(f"[INFO] quantization_config.format={fmt!r} confirmado")
return quant_config
def verify_mtp_and_visual_shards():
mtp_path = OUTPUT_PATH / "model_mtp.safetensors"
if not mtp_path.exists():
raise AssertionError(f"falta {mtp_path} -- los tensores MTP no se reinyectaron, --speculative-config no arrancara")
with safe_open(str(mtp_path), framework="pt") as f:
mtp_count = len(f.keys())
print(f"[INFO] model_mtp.safetensors: {mtp_count} tensores")
# Referencia (Fase 3/4): ~19 tensores MTP. Rango amplio a proposito -- lo que
# importa es que no este vacio ni truncado a un puñado.
if not (10 <= mtp_count <= 40):
raise AssertionError(f"conteo de tensores MTP fuera de rango razonable: {mtp_count} (esperado ~19)")
# A diferencia del checkpoint de referencia de RedHatAI (que trae vision en su
# propio model_visual.safetensors), esta version de transformers
# (Qwen3_5MoeForConditionalGeneration.save_pretrained) escribe lenguaje+vision
# juntos en el/los shard(s) de model.safetensors -- comportamiento igualmente
# valido (el index.json mapea cada tensor a su shard real sin importar el nombre
# de archivo), asi que se verifica por conteo de tensores via el index en vez de
# exigir un archivo separado.
all_names = iter_output_tensor_names()
visual_count = sum(1 for name, _shard in all_names if ".visual." in name or name.startswith("visual."))
print(f"[INFO] tensores de vision encontrados (en los shards de model.safetensors): {visual_count}")
if not (250 <= visual_count <= 450):
raise AssertionError(f"conteo de tensores de vision fuera de rango razonable: {visual_count} (esperado ~333)")
def verify_no_nan_inf_in_sample(quant_config, sample_size=20):
"""Decodifica una muestra de tensores cuantizados (weight_packed) y verifica
que no haya NaN/Inf tras la des-cuantizacion -- catch de errores numericos
silenciosos en la calibracion (scales cero/Inf, experts sin calibrar, etc.)."""
from compressed_tensors.compressors.nvfp4 import NVFP4PackedCompressor
from compressed_tensors.quantization.quant_scheme import PRESET_SCHEMES, QuantizationScheme
preset = PRESET_SCHEMES["NVFP4"]
scheme = QuantizationScheme(
targets=["Linear"],
weights=preset["weights"],
input_activations=preset.get("input_activations"),
)
all_names = iter_output_tensor_names()
packed_names = sorted(name for name, _shard in all_names if name.endswith(".weight_packed"))
if not packed_names:
raise AssertionError("no se encontro ningun tensor '.weight_packed' en OUTPUT_PATH -- nada se cuantizo")
print(f"[INFO] {len(packed_names)} tensores cuantizados (weight_packed) encontrados en total")
rng = random.Random(CALIBRATION_SEED)
sample = rng.sample(packed_names, min(sample_size, len(packed_names)))
shard_by_name = dict(all_names)
checked = 0
for packed_name in sample:
base_name = packed_name[: -len(".weight_packed")]
shard = shard_by_name[packed_name]
shard_path = OUTPUT_PATH / shard
with safe_open(str(shard_path), framework="pt") as f:
state_dict = {"weight_packed": f.get_tensor(packed_name)}
scale_name = f"{base_name}.weight_scale"
global_scale_name = f"{base_name}.weight_global_scale"
if scale_name in f.keys():
state_dict["weight_scale"] = f.get_tensor(scale_name)
if global_scale_name in f.keys():
state_dict["weight_global_scale"] = f.get_tensor(global_scale_name)
decompressed = NVFP4PackedCompressor.decompress(state_dict, scheme)
weight = decompressed["weight"]
if not torch.isfinite(weight).all():
raise AssertionError(f"tensor cuantizado {base_name} tiene NaN/Inf tras des-cuantizar")
checked += 1
print(f"[INFO] {checked} tensores cuantizados des-cuantizados sin NaN/Inf (muestra aleatoria)")
for ignored_suffix in ("mlp.gate.weight", "shared_expert_gate.weight", "embed_tokens.weight"):
if any(name.endswith(f"{ignored_suffix}_packed") for name, _s in all_names):
raise AssertionError(f"un tensor ignorado ({ignored_suffix}) fue cuantizado -- la ignore list no se aplico bien")
def verify_chat_template():
train_template_path = REPO_ROOT / "data" / "chat_template_train.jinja"
output_template_path = OUTPUT_PATH / "chat_template.jinja"
model_template_path = MODEL_PATH / "chat_template.jinja"
output_template = output_template_path.read_bytes()
train_template = train_template_path.read_bytes()
model_template = model_template_path.read_bytes()
if output_template == train_template:
raise AssertionError(
"chat_template.jinja de salida es BYTE-IDENTICO al template de masking de "
"training -- se copio el template equivocado"
)
if output_template != model_template:
raise AssertionError("chat_template.jinja de salida no coincide con el de MODEL_PATH (produccion)")
print(
f"[INFO] chat_template.jinja verificado: {len(output_template)} bytes, identico al "
"de produccion (MODEL_PATH), distinto del de masking de training"
)
def parse_args():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument(
"--verify-only",
action="store_true",
default=os.environ.get("VERIFY_ONLY", "") not in ("", "0", "false", "False"),
help="saltar calibracion/guardado, solo re-correr las verificaciones sobre OUTPUT_PATH ya existente",
)
parser.add_argument(
"--prepare-calibration",
action="store_true",
default=os.environ.get("PREPARE_CALIBRATION", "") not in ("", "0", "false", "False"),
help=(
"solo construir y guardar en disco (CALIBRATION_CACHE_PATH) la muestra de "
"calibracion ya tokenizada, SIN cargar el modelo -- correr en un proceso aparte "
"antes de la cuantizacion, para que `datasets`/streaming/red nunca compartan "
"proceso con el modelo de 67GB"
),
)
return parser.parse_args()
def prepare_calibration():
print(f"[INFO] TRAIN_DATA_PATH={TRAIN_DATA_PATH}")
print(f"[INFO] NUM_CALIBRATION_SAMPLES={NUM_CALIBRATION_SAMPLES} MAX_SEQUENCE_LENGTH={MAX_SEQUENCE_LENGTH}")
print(f"[INFO] NUM_ULTRACHAT_SAMPLES={NUM_ULTRACHAT_SAMPLES}")
print(f"[INFO] cargando tokenizer desde {MODEL_PATH} (solo tokenizer, no el modelo)")
processor = AutoProcessor.from_pretrained(str(MODEL_PATH), trust_remote_code=True)
tokenizer = processor.tokenizer
calibration_dataset = load_calibration_dataset(tokenizer)
CALIBRATION_CACHE_PATH.parent.mkdir(parents=True, exist_ok=True)
calibration_dataset.save_to_disk(str(CALIBRATION_CACHE_PATH))
print(f"[INFO] muestra de calibracion guardada en {CALIBRATION_CACHE_PATH} ({len(calibration_dataset)} ejemplos)")
def main():
args = parse_args()
print(f"[INFO] MODEL_PATH={MODEL_PATH}")
print(f"[INFO] OUTPUT_PATH={OUTPUT_PATH}")
if args.prepare_calibration:
prepare_calibration()
return
if args.verify_only:
print("[INFO] --verify-only: saltando calibracion/guardado, solo verificando OUTPUT_PATH existente")
else:
print(f"[INFO] CALIBRATION_CACHE_PATH={CALIBRATION_CACHE_PATH}")
print(f"[INFO] cargando processor desde {MODEL_PATH}")
processor = AutoProcessor.from_pretrained(str(MODEL_PATH), trust_remote_code=True)
tokenizer = processor.tokenizer
if CALIBRATION_CACHE_PATH.exists():
print(f"[INFO] cargando muestra de calibracion YA PREPARADA desde {CALIBRATION_CACHE_PATH}")
calibration_dataset = Dataset.load_from_disk(str(CALIBRATION_CACHE_PATH))
print(f"[INFO] {len(calibration_dataset)} ejemplos cargados desde el cache (sin tocar datasets/red)")
else:
print(f"[INFO] TRAIN_DATA_PATH={TRAIN_DATA_PATH}")
print(f"[INFO] NUM_CALIBRATION_SAMPLES={NUM_CALIBRATION_SAMPLES} MAX_SEQUENCE_LENGTH={MAX_SEQUENCE_LENGTH}")
print(f"[INFO] NUM_ULTRACHAT_SAMPLES={NUM_ULTRACHAT_SAMPLES}")
print(
f"[INFO] no hay cache en {CALIBRATION_CACHE_PATH} -- construyendo la muestra de "
"calibracion en este mismo proceso (usar --prepare-calibration antes evita esto)"
)
calibration_dataset = load_calibration_dataset(tokenizer)
import gc
gc.collect()
print(f"[INFO] cargando modelo desde {MODEL_PATH} (dtype=auto)")
t_load = time.time()
model = Qwen3_5MoeForConditionalGeneration.from_pretrained(
str(MODEL_PATH), dtype="auto", trust_remote_code=True
)
print(f"[INFO] modelo cargado en {time.time() - t_load:.1f}s")
report_memory("post-load")
recipe = QuantizationModifier(targets="Linear", scheme="NVFP4", ignore=QUANTIZATION_IGNORE)
data_collator = CalibrationDataCollator(tokenizer.pad_token_id or tokenizer.eos_token_id)
print("[INFO] arrancando oneshot() -- calibracion NVFP4 con moe_calibrate_all_experts=True")
t_quant = time.time()
oneshot(
model=model,
recipe=recipe,
dataset=calibration_dataset,
max_seq_length=MAX_SEQUENCE_LENGTH,
num_calibration_samples=NUM_CALIBRATION_SAMPLES,
moe_calibrate_all_experts=True,
data_collator=data_collator,
)
print(f"[INFO] oneshot() completo en {time.time() - t_quant:.1f}s")
report_memory("post-oneshot")
OUTPUT_PATH.mkdir(parents=True, exist_ok=True)
print(f"[INFO] guardando modelo cuantizado en {OUTPUT_PATH}")
t_save = time.time()
model.save_pretrained(str(OUTPUT_PATH))
processor.save_pretrained(str(OUTPUT_PATH))
print(f"[INFO] save_pretrained completo en {time.time() - t_save:.1f}s")
print(f"[INFO] reinyectando tensores MTP desde {MODEL_PATH}")
save_mtp_tensors_to_checkpoint(source_model=str(MODEL_PATH), dest_dir=str(OUTPUT_PATH))
print("[INFO] tensores MTP reinyectados")
print("[INFO] verificando checkpoint de salida")
quant_config = verify_quantization_config()
verify_mtp_and_visual_shards()
verify_no_nan_inf_in_sample(quant_config)
verify_chat_template()
total_size_gb = sum(f.stat().st_size for f in OUTPUT_PATH.rglob("*") if f.is_file()) / (1024 ** 3)
print(f"[INFO] tamano total de OUTPUT_PATH: {total_size_gb:.2f}GB")
print("[INFO] cuantizacion NVFP4 completa y verificada")
if __name__ == "__main__":
main()
scripts/32_gate2_toolcalls.py
+24 -4
View File
@@ -32,9 +32,13 @@ import requests
REPO_ROOT = Path(__file__).resolve().parent.parent
HOLDOUT_PATH = REPO_ROOT / "data" / "holdout_prompts.jsonl"
RESULTS_PATH = REPO_ROOT / "data" / "gate2_results.json"
RESULTS_PATH = REPO_ROOT / "data" / os.environ.get("GATE2_RESULTS_FILENAME", "gate2_results.json")
BASE_URL = os.environ.get("VLLM_EVAL_URL", "http://localhost:8001")
MODEL_NAME = os.environ.get("VLLM_EVAL_MODEL", "qwen3.6-35b-a3b-mcp-bf16")
# 1024 dejaba cortar la respuesta a mitad de razonamiento en modelos con
# --reasoning-parser activo antes de emitir el tool_call -- ver hallazgo de
# Fase 5 (misma causa que el fix de gate3, max_tokens 512->2048).
GATE2_MAX_TOKENS = int(os.environ.get("GATE2_MAX_TOKENS", "2048"))
def load_holdout():
@@ -92,13 +96,13 @@ def validate_tool_call(tool_call, tools):
return True, None
def call_vllm(prompt, tools, timeout=120):
def call_vllm(prompt, tools, timeout=240):
payload = {
"model": MODEL_NAME,
"messages": [{"role": "user", "content": prompt}],
"tools": to_openai_tools(tools),
"tool_choice": "auto",
"max_tokens": 1024,
"max_tokens": GATE2_MAX_TOKENS,
"temperature": 0.0,
}
resp = requests.post(f"{BASE_URL}/v1/chat/completions", json=payload, timeout=timeout)
@@ -133,11 +137,24 @@ def main():
continue
message = response["choices"][0]["message"]
# Se guarda siempre el texto completo (content + reasoning) para poder auditar
# con criterio humano los casos que fallan o quedan sin tool_call -- antes no se
# guardaba nada de esto, lo que hacia imposible diagnosticar truncamiento.
content = message.get("content") or ""
reasoning = message.get("reasoning") or ""
tool_calls = message.get("tool_calls") or []
if not tool_calls:
stats[mcp]["no_tool_call"] += 1
stats["__global__"]["no_tool_call"] += 1
results.append({"mcp": mcp, "prompt": ex["prompt"], "tool_calls": None, "valid": None})
results.append({
"mcp": mcp,
"prompt": ex["prompt"],
"tool_calls": None,
"valid": None,
"content": content,
"reasoning": reasoning,
"finish_reason": response["choices"][0].get("finish_reason"),
})
continue
all_valid = True
@@ -161,6 +178,9 @@ def main():
"tool_calls": [tc["function"]["name"] for tc in tool_calls],
"valid": all_valid,
"errors": errors,
"content": content,
"reasoning": reasoning,
"finish_reason": response["choices"][0].get("finish_reason"),
})
if (i + 1) % 20 == 0:
scripts/33_gate3_adherencia.py
+22 -4
View File
@@ -27,12 +27,17 @@ from pathlib import Path
import requests
REPO_ROOT = Path(__file__).resolve().parent.parent
RESULTS_PATH = REPO_ROOT / "data" / "gate3_results.json"
RESULTS_PATH = REPO_ROOT / "data" / os.environ.get("GATE3_RESULTS_FILENAME", "gate3_results.json")
EVAL_URL = os.environ.get("VLLM_EVAL_URL", "http://localhost:8001")
EVAL_MODEL = os.environ.get("VLLM_EVAL_MODEL", "qwen3.6-35b-a3b-mcp-bf16")
PROD_URL = os.environ.get("VLLM_PROD_URL", "http://localhost:8000")
PROD_MODEL = os.environ.get("VLLM_PROD_MODEL", "qwen3.6-35b-a3b")
# 512 dejaba cortar la respuesta a mitad de razonamiento en los prompts mas
# abiertos (modelo de razonamiento con --reasoning-parser activo) antes de
# emitir el contenido final -- un FAIL por presupuesto de tokens agotado, no
# por adherencia real. Ver hallazgo de Fase 5.
GATE3_MAX_TOKENS = int(os.environ.get("GATE3_MAX_TOKENS", "2048"))
# Checklists por skill: (skill, tipo, prompt, [substrings esperados en la respuesta, any-of])
CHECKLISTS = [
@@ -103,10 +108,10 @@ def call_model(base_url, model_name, prompt):
payload = {
"model": model_name,
"messages": [{"role": "user", "content": prompt}],
"max_tokens": 512,
"max_tokens": GATE3_MAX_TOKENS,
"temperature": 0.0,
}
resp = requests.post(f"{base_url}/v1/chat/completions", json=payload, timeout=120)
resp = requests.post(f"{base_url}/v1/chat/completions", json=payload, timeout=240)
resp.raise_for_status()
data = resp.json()
message = data["choices"][0]["message"]
@@ -147,9 +152,20 @@ def run_checklist(base_url, model_name, label):
print(f" [ERROR] {skill}/{kind}: {e}")
continue
# Se guarda siempre el texto completo (content + reasoning) para poder auditar
# con criterio humano los casos que fallan -- antes solo se guardaba passed/hits,
# lo que hacia imposible revisar despues que dijo realmente el modelo.
if kind == "adherencia":
passed, hits = check_adherencia(response, expected)
rows.append({"skill": skill, "kind": kind, "prompt": prompt, "passed": passed, "hits": hits})
rows.append({
"skill": skill,
"kind": kind,
"prompt": prompt,
"passed": passed,
"hits": hits,
"content": response["content"],
"reasoning": response["reasoning"],
})
print(f" {'OK ' if passed else 'FAIL'} {skill:20s} adherencia hits={hits}")
else:
passed = check_no_activacion(response)
@@ -159,6 +175,8 @@ def run_checklist(base_url, model_name, label):
"prompt": prompt,
"passed": passed,
"tool_calls": [tc["function"]["name"] for tc in response["tool_calls"]],
"content": response["content"],
"reasoning": response["reasoning"],
})
print(f" {'OK ' if passed else 'FAIL'} {skill:20s} {kind:20s} tool_calls={len(response['tool_calls'])}")
return rows
scripts/34_gate4_e2e.py
+1 -1
View File
@@ -32,7 +32,7 @@ import requests
REPO_ROOT = Path(__file__).resolve().parent.parent
SCHEMAS_DIR = REPO_ROOT / "data" / "schemas"
RESULTS_PATH = REPO_ROOT / "data" / "gate4_results.json"
RESULTS_PATH = REPO_ROOT / "data" / os.environ.get("GATE4_RESULTS_FILENAME", "gate4_results.json")
EVAL_URL = os.environ.get("VLLM_EVAL_URL", "http://localhost:8001")
EVAL_MODEL = os.environ.get("VLLM_EVAL_MODEL", "qwen3.6-35b-a3b-mcp-bf16")