Metadata-Version: 2.4
Name: nexpi
Version: 0.1.0
Summary: Chip virtual de generacion de video: anclas por difusion en la integrada, propagacion 2.5D en CPU y acelerador universal para modelos de video sin GPU dedicada
Author: Nexora Technology LLC
Maintainer: Nexora Technology LLC
Keywords: difusion,video,aceleracion,openvino,igpu,cpu,diffusers,inferencia,plazo,sla
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: License :: Other/Proprietary License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Topic :: Multimedia :: Video
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Requires-Python: >=3.10
Description-Content-Type: text/markdown
Requires-Dist: openvino>=2025.4.0
Requires-Dist: numpy>=2.0
Requires-Dist: opencv-python>=4.10
Requires-Dist: transformers>=4.50
Requires-Dist: sentencepiece>=0.2
Requires-Dist: diffusers>=0.30
Requires-Dist: torch>=2.4
Requires-Dist: huggingface_hub>=0.30
Requires-Dist: psutil>=5.9
Requires-Dist: typer>=0.12
Requires-Dist: rich>=13
Requires-Dist: fastapi>=0.110
Requires-Dist: uvicorn>=0.30
Requires-Dist: pydantic>=2
Provides-Extra: dev
Requires-Dist: pytest>=8; extra == "dev"

# NEXPI

Dos piezas que comparten una misma tesis: **el video es casi todo redundante, y
el hardware que la gente ya tiene esta desaprovechado.**

```
nexpi_accel/   ACELERADOR UNIVERSAL — hace que modelos de video de otros corran
               en maquinas sin GPU dedicada (integrada, NPU o solo CPU)
nexpi/         GENERADOR PROPIO 2.5D — texto -> mp4 1080p con camara cinematografica
```

---

## 1. NEXPI Accel — acelerador universal de modelos de video

**El problema:** todo lo que existe para acelerar generacion de video esta hecho
para NVIDIA. FastVideo soporta NVIDIA y Apple Silicon, y nada mas. Las tecnicas
de atencion dispersa (SVG, VSA, Sliding Tile) exigen kernels CUDA o CK-Tile. Si
tienes un portatil con grafica integrada, no hay nada para ti.

**Lo que hace NEXPI:** se enchufa a un pipeline de difusion que ya tengas y
aplica cinco palancas que **se multiplican entre si**:

| # | Palanca | Coste | Ganancia |
|---|---|---|---|
| 1 | pasos (cache adaptativa) | lineal | 2-6x |
| 2 | pixeles (superresolucion) | **cuadratico** | 2-4x |
| 3 | fotogramas (interpolacion) | lineal | 2-4x |
| 4 | precision (fp16 / int8) | lineal | 2x |
| 5 | unidad de ejecucion | segun silicio | 2.5x |

```bash
python -m nexpi_accel hardware              # que hay en esta maquina, MEDIDO
python -m nexpi_accel plan --segundos 60    # como repartir el computo
python -m nexpi_accel video "un gato en la ventana" --segundos 90
```

```python
from nexpi_accel import acelerar
with acelerar(pipe, presupuesto_error=0.03) as a:   # cualquier pipeline de diffusers
    video = pipe(prompt, num_frames=16).frames[0]
print(a.informe())
```

### El chip se enchufa solo

No hace falta decirle a NEXPI que modelo es ni pasarle nada: lo identifica por lo
que ES (el modulo que evalua la difusion, sus parametros contados de verdad y lo
que admite su llamada) y le aplica el plan que salga del hardware ya medido.

```python
import nexpi_accel.auto                  # una linea: todo lo que cargues despues sale acelerado
pipe = DiffusionPipeline.from_pretrained("Lightricks/LTX-Video")
video = pipe(prompt, num_frames=97).frames[0]
```

O envolviendo por fuera un programa que ya tengas, sin abrirlo:

```bash
python -m nexpi_accel detectar               # que modelos hay ya en la maquina
python -m nexpi_accel auto mi_script.py      # lo ejecuta con el chip puesto
python -m nexpi_accel auto mi_script.py --segundos 60 --calidad rapida
```

Sin objetivo de tiempo solo tira de la palanca que **no cambia lo que pediste**:
la cache adaptativa (misma resolucion, mismos fotogramas, mismos pasos). Con
objetivo de tiempo entran las cinco: genera mas pequeno y sube con
superresolucion, genera menos fotogramas y los repone interpolando, recorta
pasos y reparte las etapas entre las unidades. Lo que quita, lo devuelve: si
pides 16 fotogramas de 512x512, recibes 16 de 512x512.

Funciona con lo que ya tengas descargado (cache de HuggingFace, ComfyUI, A1111):
no hay que convertir ni volver a bajar nada.

### Contrato de plazo: lo que no hace nadie

Todos los aceleradores del mercado te dan velocidad. Ninguno te da una
**garantia**. NEXPI si:

```bash
nexpi-accel contrato "un faro al atardecer" --plazo 30 --certificado cert.json
```

```python
from nexpi_accel import contrato
oferta = contrato.negocia(pipe, plazo=30, height=512, width=512)   # antes de gastar un vatio
print(oferta.texto())
salida, cert = contrato.ejecuta(pipe, plazo=30, prompt="un faro", height=512, width=512)
print(cert.texto())
```

Tres piezas:

1. **Negociacion**: dice SI o NO *antes* de empezar, y si no puede, dice cual es
   el mejor tiempo alcanzable en esta maquina.
2. **Controlador**: dentro del bucle mide el ritmo real, aprieta o afloja la
   cache y, si el siguiente paso no cabe en el plazo, **entrega lo que tiene**.
   Un modelo de difusion siempre tiene una imagen a medio hacer utilizable: por
   eso el plazo se puede cumplir siempre.
3. **Certificado**: que se prometio, que paso y con que se midio, con huella
   para que no se pueda retocar sin que se note.

**Medido en SD1.5 a 512x512 (CPU, sin GPU dedicada):**

| plazo | real | |
|---|---|---|
| 240 s | 64,8 s | CUMPLIDO (previsto 68,1 s: 5% de error) |
| 90 s | 78,8 s | CUMPLIDO |
| 40 s | 29,9 s | CUMPLIDO, entregado al vencer (2 pasos; un tercero no cabia) |
| 25 s | 20,7 s | CUMPLIDO, entregado al vencer |
| 15 s | 10,2 s | CUMPLIDO, entregado al vencer |

La promesa **no sale de un modelo teorico**: sale de lo medido en esta maquina y
guardado en `cache/contratos.json`, escalado por pixeles cuando cambia la
resolucion. El certificado dice siempre de donde sale la cifra y con cuantas
ejecuciones se sostiene. Y lo que dice de la desviacion es lo que de verdad se
ha medido (el error de las verificaciones de la cache contra la red real), no la
distancia al resultado sin acelerar, que exigiria generarlo dos veces.

**Lo que aporta y no existe en ningun otro sitio:**

- **Presupuesto de error en lazo cerrado** en vez de umbral fijo calibrado a mano.
  Medido: **33,5 dB con 28,7/30 evaluaciones** frente a **20,4 dB con 26/30** del
  metodo publicado.
- **Coeficiente de extrapolacion aprendido** por minimos cuadrados en cada
  verificacion. Extrapolar a ciegas hunde la calidad de 33,5 a 21,1 dB en
  modelos destilados; NEXPI lo detecta y se comporta como copia cuando conviene.
- **Autocalibracion**: mide su propio fallo cada pocos saltos y corrige la
  ganancia. Por eso funciona igual en cualquier modelo y en cualquier hardware.
- **Enganche universal**: envuelve `pipe.unet`/`pipe.transformer`, cuenta pasos
  por cambio de timestep (acierta con CFG en lote y separado) y lleva una cache
  por rama de guia. Vale para Wan, LTX, CogVideoX, AnimateDiff, SVD y pipelines
  propios, sin una linea de codigo por modelo.
- **Runtime OpenVINO** que ejecuta modelos de diffusers en iGPU, NPU o CPU, con
  captura automatica de las formas reales del modelo y respaldo por
  `torch.compile`.
- **Planificador con presupuesto de tiempo**: le dices "en 60 segundos" y reparte
  las cinco palancas sobre el hardware que ha medido.

Detalles y fuentes en [docs/ACELERADOR.md](docs/ACELERADOR.md).

### Edicion y juegos (medido)

- **Edicion**: `nexpi_accel/ffmpeg_accel.py` elige la ruta mas rapida de ffmpeg.
  Recorte de 6 s **13x** mas rapido (sin recodificar), transcodificacion **1,8x**
  con la cadena entera en la integrada. Y una regla medida: decodificar por
  hardware solo compensa si la cadena sigue en hardware.
- **Juegos**: `nexpi_accel/juegos.py` (NEXPI Frame Booster) sintetiza fotogramas
  intermedios con flujo optico y warping, como DLSS 3 Frame Generation o AFMF pero
  sin hardware dedicado. **14,5 ms por fotograma a 720p** (69 fps posibles),
  **60,2 fps de salida desde 30 a 1080p** con ~30 ms de latencia anadida, 47-50 dB
  de calidad. Ningun chip hace correr un juego en un PC sin requisitos: lo que
  hace es duplicar los fotogramas presentados y permitir renderizar mas pequeno.

### Marca

`marca/lamina_chip.py` y `marca/lamina_chip_3d.py` generan las laminas de producto
por geometria vectorial; `marca/pdf_nexpi.py` el dossier tecnico (solo cifras
medidas); `marca/video_promo.py` el video promocional en espanol e ingles, con voz
neuronal y musica sintetizada, todo de cero.

### Se puede sumar la CPU y la integrada? (experimento)

Si, pero mucho menos de lo que promete la aritmetica. Medido con la maquina en
reposo: iGPU sola 15,91 fotogramas/s, CPU sola 6,72, suma teorica 22,63, y el
mejor reparto (el de NEXPI, 70/30 segun velocidad medida) da **16,39: solo un
+3 %**.

La razon esta medida: **al trabajar a la vez, cada unidad pierde ~24 %** porque
la integrada no tiene memoria propia y **compiten por el mismo bus**. No son dos
unidades independientes, son dos consumidores del mismo recurso escaso.

El experimento completo, con el metodo y las consecuencias de diseno, en
[docs/EXPERIMENTO_GPU_VIRTUAL.md](docs/EXPERIMENTO_GPU_VIRTUAL.md).

---

## 2. NEXPI (generador 2.5D)

Texto -> video 1080p en un portatil sin GPU: un ancla por difusion por plano
(SDXS 1 paso + TAESD, ~0,45 s en la integrada), profundidad, realce x4, capas
2.5D y movimiento de camara por warp en CPU (~18 ms/fotograma).

```bash
python -m nexpi generar "Un faro solitario en un acantilado al atardecer. Las olas rompen contra las rocas" -d 12
python -m nexpi api        # interfaz web en http://127.0.0.1:5050
```

Clip de 12 s en ~17 s (x1,1 tiempo real). Limite honesto: cada plano es una
imagen con movimiento de camara real por profundidad, no hay movimiento de
personajes dentro del plano. Detalles en [docs/ARQUITECTURA.md](docs/ARQUITECTURA.md).

---

## Hardware de referencia (medido, no de catalogo)

Portatil i9-12900H + Iris Xe 96 EU, **sin GPU NVIDIA**:

| Unidad | Medido |
|---|---|
| Iris Xe via OpenVINO fp16 | **756 GFLOP/s** |
| CPU via OpenVINO | 326 GFLOP/s |
| CPU via torch | 296 GFLOP/s |

La integrada rinde **2,5x la CPU** y practicamente todo el software de video la
ignora.

Mediciones completas y metodologia en [docs/HARDWARE_MEDIDO.md](docs/HARDWARE_MEDIDO.md)
e [docs/INVESTIGACION.md](docs/INVESTIGACION.md).

## Instalacion

```bash
pip install -r requirements.txt      # ffmpeg debe estar en el PATH
python bench/fetch_models.py         # pesos del generador 2.5D
python bench/fetch_video_model.py    # modelo de video para el acelerador
```

## Nexpigramas: LTX-Video en cualquier PC (2026-09-02)

LTX-Video 2B destilado corre entero en este portatil sin GPU dedicada: T5-XXL en streaming desde GGUF, transformer en 28 bloques OpenVINO int8 (CPU 6,6 s/paso, Iris Xe 3,9 s/paso, torch 19,5 s), VAE por baldosas. Clip 512x320x49: 87 s en la integrada, 107 s en CPU. Detalles y trampas en `docs/NEXPIGRAMAS.md`.

    python -m nexpi_accel.ltx_cpu "prompt" --ancho 512 --alto 320 --fotogramas 49 --backend gpu -o clip.mp4
    python -m nexpi_accel.nexpigramas plan --ancho 1024 --alto 640 --fps 48 --duracion 2 --presupuesto 300
