Plan de Integración: TurboQuant en Orión

Estado actual

• Runtime: llama.cpp / GGUF
• Modelos locales: Llama, Gemma, Phi, Qwen
• Plataformas: Android (Play Store) + iOS (App Store)

---

Qué es TurboQuant y por qué importa para Orión

TurboQuant (Google Research, ICLR 2026) comprime la KV cache a ~3 bits sin pérdida de precisión. Combina dos algoritmos:

1. PolarQuant: Convierte vectores de coordenadas cartesianas a polares, eliminando la normalización costosa y el overhead de memoria de los métodos tradicionales.
2. QJL (Quantized Johnson-Lindenstrauss): Reduce cada valor residual a 1 solo bit de signo (+1/-1), sin overhead de memoria.

Impacto concreto en Orión

Métrica	Sin TurboQuant	Con TurboQuant	Mejora
KV Cache (8B model, 4K ctx)	~1 GB	~170 MB	~6x
Contexto máximo (6GB RAM)	~4K tokens	~16-24K tokens	4-6x
Velocidad attention	Baseline	Hasta 8x (GPU)	Significativa

Esto significa: conversaciones más largas en Modo Legado/Esencia sin que el teléfono se quede sin memoria.

---

Ruta de Integración: 3 Fases

FASE 1 — Hoy (Producción inmediata, sin esperar a TurboQuant)

Objetivo: Optimizar la cuantización de modelos GGUF que ya sirves.

1.1 Usar cuantización con importance matrix (imatrix)

Los modelos que ofreces en Orión deberían usar imatrix para maximizar calidad a bajo bitrate:

# Generar importance matrix con dataset de calibración
./llama-imatrix \
  -m modelo-base-F16.gguf \
  -f calibration-data.txt \
  --chunk 512 \
  -o modelo-imatrix.dat

# Cuantizar con imatrix (Q4_K_M recomendado para móvil)
./llama-quantize \
  --imatrix modelo-imatrix.dat \
  modelo-base-F16.gguf \
  modelo-Q4_K_M.gguf Q4_K_M

# Para dispositivos con más RAM (iPad Pro, Android flagship)
./llama-quantize \
  --imatrix modelo-imatrix.dat \
  modelo-base-F16.gguf \
  modelo-Q5_K_M.gguf Q5_K_M

1.2 Estrategia de cuantización por tensor

Protege los tensores críticos para Modo Legado (atención = memoria de contexto):

# Cuantizar con tensores de atención a mayor precisión
./llama-quantize \
  --imatrix modelo-imatrix.dat \
  --tensor-type "attn_v=q5_k" \
  --tensor-type "attn_k=q5_k" \
  --tensor-type "ffn_down=q5_k" \
  modelo-base-F16.gguf \
  modelo-orion-optimized.gguf Q4_K_M

Esto da Q4 general pero Q5 en atención → mejor retención de contexto largo para Legado/Esencia.

1.3 Tabla de modelos recomendados para Orión

Dispositivo	RAM	Modelo	Cuantización	Tamaño
Android medio (6-8GB)	6GB	Qwen3-1.5B / Phi-3-mini	Q4_K_M + imatrix	~1.2GB
Android flagship (12GB+)	12GB	Llama-3.1-8B / Gemma-2-9B	Q4_K_M + imatrix	~4.5GB
iPhone 15/16	6-8GB	Qwen3-1.5B / Phi-3-mini	Q4_K_M + imatrix	~1.2GB
iPad Pro	16GB	Llama-3.1-8B	Q5_K_M + imatrix	~5.5GB

---

FASE 2 — Corto plazo (1-3 meses): KV Cache Quantization en llama.cpp

Objetivo: Activar cuantización de KV cache cuando llama.cpp lo soporte estable.

Estado actual del ecosistema

• ExLlamaV2 (turboderp): Ya tiene KV cache 4-bit funcional con Hadamard transform.
• llama.cpp: KV cache quantization ha sido solicitada múltiples veces. Hay un PR histórico que no se mergeó por ser demasiado invasivo. Nuevo intento en progreso.
• TurboQuant en llama.cpp: Issue #20977 abierto HOY (25 marzo 2026). Fork experimental ya existe: github.com/mudler/llama.cpp/tree/feat/turbo-quant

Acciones

1. Monitorear el fork de mudler: feat/turbo-quant ya compila y cuantiza. Evaluar resultados.
2. Probar KV cache quantization cuando se merge en main: El parámetro probable será algo como --cache-type-k q4_0 --cache-type-v q4_0
3. Preparar la API de Orión: Añadir parámetros de configuración para KV cache quantization en los settings de la app:

{
  "inference_settings": {
    "kv_cache_quantization": {
      "enabled": false,
      "key_bits": 4,
      "value_bits": 4,
      "method": "default"
    }
  }
}

4. Testing con benchmarks de Orión: Crear suite de test específica para Modo Legado:
   • Retención de personalidad después de 2K+ tokens de contexto
   • Coherencia de memorias inyectadas
   • Calidad de voz clonada con contexto comprimido

---

FASE 3 — Medio plazo (3-6 meses): TurboQuant nativo

Objetivo: Integrar PolarQuant + QJL como método de KV cache en Orión.

Dependencias

• Paper de TurboQuant publicado con código: arxiv.org/abs/2504.19874
• Implementación en GGML/llama.cpp (vía PR comunitario o fork)
• Validación en ARM (Android) y Apple Silicon (iOS)
• Benchmarks en dispositivos reales (no solo H100)

Implementación conceptual (PolarQuant en GGML)

El núcleo de PolarQuant es una rotación aleatoria seguida de conversión a coordenadas polares:

// Pseudocódigo del paso PolarQuant para KV cache
// 1. Rotación aleatoria (Hadamard o random orthogonal)
void polar_quant_encode(float* kv_vector, int dim, 
                         uint8_t* quantized_output) {
    // Paso 1: Aplicar rotación aleatoria (suaviza distribución)
    apply_random_rotation(kv_vector, dim);
    
    // Paso 2: Convertir pares (x,y) → (r, θ) polar
    for (int i = 0; i < dim; i += 2) {
        float r = sqrt(kv_vector[i]*kv_vector[i] + 
                       kv_vector[i+1]*kv_vector[i+1]);
        float theta = atan2(kv_vector[i+1], kv_vector[i]);
        
        // Paso 3: Cuantizar θ uniformemente (la distribución 
        // post-rotación es predecible → no necesita normalización)
        quantized_output[i/2] = uniform_quantize(theta, bits);
        // El radio se maneja recursivamente con pares de radios
    }
}

// QJL: 1 bit para el residuo
void qjl_residual(float* residual, int dim, uint8_t* sign_bits) {
    // Proyección JL + reducción a signo
    for (int i = 0; i < dim; i++) {
        sign_bits[i/8] |= (residual[i] > 0 ? 1 : 0) << (i % 8);
    }
}

Consideraciones móviles

• ARM NEON: La rotación Hadamard y las operaciones polares se vectorizan bien en NEON.
• Apple AMX/ANE: Metal compute shaders para la cuantización en lote.
• Memoria: El overhead de TurboQuant es casi cero (vs ~1-2 bits extra en métodos tradicionales).
• Thermal throttling: Menos memoria → menos bus activity → menos calor → mejor sustained performance en móvil.

---

Impacto por modo de Orión

🧠 Memoria Persistente

• KV cache 6x menor → puedes inyectar 6x más memorias del usuario en el contexto
• Resultado: Orión recuerda más con menos RAM

💜 Modo Esencia

• Contexto más largo → la personalidad clonada se mantiene coherente en conversaciones largas
• Puedes almacenar más "rasgos de personalidad" en el prompt de sistema

🕊️ Modo Legado

• Este es el mayor beneficiario: reconstruir la esencia de alguien requiere contexto largo (memorias, estilo, voz)
• Con TurboQuant: 16-24K tokens de contexto en un teléfono de 6GB vs 4K actual
• Diferencia entre una conversación superficial y una experiencia profunda

📡 Modo Cercano

• No impacta directamente (mesh networking es independiente de inferencia)

---

Siguiente paso inmediato

Hoy mismo puedes:

1. Re-cuantizar tus modelos GGUF con imatrix + tensores de atención protegidos (Fase 1)
2. Seguir el Issue #20977 de llama.cpp para TurboQuant
3. Probar el fork mudler/llama.cpp feat/turbo-quant

---

Referencias

• TurboQuant paper
• PolarQuant paper
• QJL paper
• llama.cpp Issue #20977 - TurboQuant support
• Fork experimental
• llama.cpp Discussion #5932 - 4-bit KV Cache