terminato 1.0.0

Framework de entrenamiento dirigido con control dinámico de GPU/NVMe y análisis de capas

Terminato v1.0.0

Framework de Entrenamiento Dirigido con Control Dinámico de GPU/NVMe

Sistema completo para entrenar, fusionar y analizar modelos de IA con selección dinámica de dispositivos, interfaz web intuitiva y API REST profesional.

---

📋 Tabla de Contenidos

• Características
• Instalación
• Uso Rápido
• API REST
• Integración
• Documentación
• Licencia

---

✨ Características

🎯 Selección Dinámica de Dispositivos

• Detección automática de GPUs NVIDIA
• Detección de discos NVMe
• Selección interactiva desde interfaz web
• Monitoreo de memoria en tiempo real
• Soporte para múltiples GPUs

🏋️ Entrenamientos Avanzados

• Crear sesiones de entrenamiento configurables
• Congelación selectiva de capas
• Learning rate diferenciado por capa
• Early stopping inteligente (12 iteraciones similares)
• Guardado automático de checkpoints
• Monitoreo en tiempo real del progreso

🔀 Fusión de Modelos

• Fusionar 2 o más modelos
• Estrategias: average, weighted, max, min
• Eliminación automática de pesos duplicados
• Combinación de especialidades de modelos
• Preservación de arquitectura

🔬 Análisis Profundo de Capas

• Evaluación por capa individual
• Detección de problemas de entrenamiento
• Análisis de gradientes
• Identificación de neuronas muertas
• Reporte de salud de capas
• Recomendaciones de reentrenamiento

🧠 Reinforcement Learning Dirigido

• Feedback específico por capa
• Corrección automática de errores
• Steering inteligente de modelos
• Aprendizaje relacional multimodal
• Integración con TenMiNaTor

🌐 Interfaz Web Profesional

• Dashboard intuitivo
• 4 tabs principales: Dispositivos, Entrenamiento, Sesiones, Análisis
• Monitoreo en tiempo real
• Exportación de resultados
• Responsive design

🔌 API REST Completa

• 10+ endpoints documentados
• Swagger UI interactivo
• ReDoc para documentación
• CORS configurado
• Validación de datos con Pydantic

---

📦 Instalación

Instalación Base

pip install terminato

Instalación con Extras

# Almacenamiento y datos
pip install terminato[storage,data]

# Deep Learning adicional
pip install terminato[tensorflow,jax]

# Visión y Audio
pip install terminato[vision,audio]

# Frameworks relacionados
pip install terminato[teminador,tenminatorch,terminator,terminatodo]

# Desarrollo
pip install terminato[dev]

# Monitoreo
pip install terminato[monitoring]

# Combinaciones recomendadas
pip install terminato[ml-complete]
pip install terminato[vision-complete]
pip install terminato[nlp-complete]
pip install terminato[research]

# Todo
pip install terminato[all]

Instalación desde GitHub

pip install git+https://github.com/yoqer/Terminato.git

Instalación para Desarrollo

git clone https://github.com/yoqer/Terminato.git
cd Terminato
pip install -e .[dev,all]

---

🚀 Uso Rápido

1. Iniciar Servidor

# Desarrollo
python -m uvicorn terminato.api.app:app --reload

# Producción
python -m uvicorn terminato.api.app:app --host 0.0.0.0 --port 8000 --workers 4

Acceder a: http://localhost:8000

2. Detectar Dispositivos

from terminato import DeviceManager

device_mgr = DeviceManager()
devices = device_mgr.get_available_devices()

for device in devices:
    print(f"GPU: {device['name']}, Memoria: {device['memory_gb']}GB")

3. Crear Sesión de Entrenamiento

from terminato import TrainingManager
import torch

device = torch.device("cuda:0")
trainer = TrainingManager(device)

session_id = trainer.create_training_session(
    session_name="mi_entrenamiento",
    model_path="./modelos/modelo.pt",
    dataset_path="./datos/dataset",
    config={
        "learning_rate": 0.001,
        "batch_size": 32,
        "max_epochs": 100
    }
)

print(f"Sesión creada: {session_id}")

4. Congelar Capas y Entrenar

# Congelar capas específicas
trainer.freeze_layers(session_id, ["layer1", "layer2"])

# Iniciar entrenamiento
trainer.start_training(session_id, max_epochs=100)

# Ver estado
status = trainer.get_training_status(session_id)
print(f"Progreso: {status['progress']:.1%}")

5. Analizar Capas

# Analizar capa específica
analysis = trainer.evaluate_layer(session_id, "layer3")

print(f"Precisión: {analysis['accuracy']:.2%}")
print(f"Tasa de error: {analysis['error_rate']:.2%}")
print(f"Neuronas muertas: {analysis['dead_neurons']}")

6. Fusionar Modelos

# Fusionar múltiples modelos
fused_model = trainer.fuse_models(
    session_id,
    [
        "./modelos/modelo1.pt",
        "./modelos/modelo2.pt",
        "./modelos/modelo3.pt"
    ],
    strategy="weighted"
)

print("Modelos fusionados exitosamente")

---

🌐 API REST

Endpoints Principales

Dispositivos:

• GET /api/devices - Listar dispositivos disponibles
• POST /api/devices/select - Seleccionar GPU/NVMe
• GET /api/devices/status - Estado de dispositivos

Entrenamientos:

• POST /api/training/create - Crear sesión
• POST /api/training/start - Iniciar entrenamiento
• GET /api/training/status/{session_id} - Ver estado
• POST /api/training/stop/{session_id} - Detener entrenamiento
• GET /api/training/sessions - Listar sesiones

Modelos:

• POST /api/models/fuse - Fusionar modelos
• POST /api/models/upload - Subir modelo
• GET /api/models/list - Listar modelos

Análisis:

• POST /api/layers/analyze - Analizar capa
• GET /api/layers/report/{session_id} - Reporte de capas

Documentación Interactiva

• Swagger UI: http://localhost:8000/docs
• ReDoc: http://localhost:8000/redoc

---

🔗 Integración con Otros Frameworks

Con TenMiNaTor

from terminato import TrainingManager
from teminador import TenMiNaTor

trainer = TrainingManager(device)
fusion = TenMiNaTor()

# Entrenar y fusionar
session_id = trainer.create_training_session(...)
trainer.start_training(session_id)

# Usar TenMiNaTor para análisis
models = [f"./modelos/modelo_{i}.pt" for i in range(3)]
fused = fusion.fuse_models(models)

Con TerminaTodo

from terminato import TrainingManager
from terminatodo import UnifiedStorageManager

storage = UnifiedStorageManager()
trainer = TrainingManager(device)

# Buscar datasets
datasets = storage.search_files("*.csv", ["local", "cloud"])

# Entrenar con cada dataset
for dataset in datasets:
    session_id = trainer.create_training_session(
        dataset_path=dataset['path']
    )
    trainer.start_training(session_id)

Con TERMINATOR

from terminato import TrainingManager
from terminator import TERMINATOR

trainer = TrainingManager(device)
inference = TERMINATOR()

# Entrenar modelo
session_id = trainer.create_training_session(...)
trainer.start_training(session_id)

# Usar para inferencia dirigida
model_path = trainer.get_model_path(session_id)
results = inference.infer(model_path=model_path, input_data=data)

---

📁 Estructura del Proyecto

terminato/
├── api/
│   ├── app.py              # API REST con FastAPI
│   ├── routes.py           # Rutas de API
│   └── __init__.py
├── core/
│   ├── device_manager.py   # Gestión de GPU/NVMe
│   ├── config.py           # Configuración
│   └── __init__.py
├── training/
│   ├── trainer.py          # Manager de entrenamientos
│   ├── layer_controller.py # Control de capas
│   └── __init__.py
├── models/
│   ├── loader.py           # Carga de modelos
│   ├── fusion.py           # Fusión de modelos
│   └── __init__.py
├── analysis/
│   ├── layer_analyzer.py   # Análisis de capas
│   ├── metrics.py          # Métricas
│   └── __init__.py
├── web/
│   ├── index.html          # Interfaz web
│   ├── static/             # CSS, JS
│   └── __init__.py
├── config/
│   ├── default.yaml        # Configuración por defecto
│   └── __init__.py
├── requirements.txt        # Dependencias
├── setup.py                # Configuración PyPI
├── README.md               # Este archivo
└── __init__.py

---

⚙️ Configuración

Editar config/default.yaml:

server:
  host: "0.0.0.0"
  port: 8000
  workers: 4
  log_level: "info"

training:
  max_iterations: 12
  early_stopping: true
  checkpoint_interval: 10
  
device:
  auto_detect: true
  memory_fraction: 0.9
  cuda_visible_devices: "0,1,2,3"

storage:
  models_dir: "./models"
  datasets_dir: "./datasets"
  checkpoints_dir: "./checkpoints"
  logs_dir: "./logs"

---

📊 Ejemplos Completos

Fine-Tuning de BERT

from terminato import TrainingManager
import torch

device = torch.device("cuda:0")
trainer = TrainingManager(device)

# Crear sesión
session_id = trainer.create_training_session(
    "bert_finetune",
    "./modelos/bert-base.pt",
    "./datos/mi_dataset",
    {
        "learning_rate": 0.00005,
        "batch_size": 16,
        "max_epochs": 3
    }
)

# Congelar capas base
trainer.freeze_layers(session_id, [
    "embeddings",
    "encoder.layer.0",
    "encoder.layer.1",
    "encoder.layer.2"
])

# Entrenar
trainer.start_training(session_id)

# Analizar
analysis = trainer.evaluate_layer(session_id, "encoder.layer.11")
print(f"Precisión final: {analysis['accuracy']:.2%}")

Ensemble de Modelos

# Entrenar múltiples modelos
models = []
for i in range(3):
    session_id = trainer.create_training_session(
        f"modelo_{i}",
        f"./modelos/base_{i}.pt",
        "./datos/dataset"
    )
    trainer.start_training(session_id)
    models.append(trainer.get_model_path(session_id))

# Fusionar
fused = trainer.fuse_models(session_id, models, strategy="weighted")
print("Ensemble creado")

---

🚀 Despliegue

Local

python -m uvicorn terminato.api.app:app --reload

Producción

python -m uvicorn terminato.api.app:app \
  --host 0.0.0.0 \
  --port 8000 \
  --workers 4 \
  --log-level info

Docker

docker build -t terminato:latest .
docker run -d \
  --gpus all \
  -p 8000:8000 \
  -v $(pwd)/modelos:/app/modelos \
  -v $(pwd)/datos:/app/datos \
  terminato:latest

Kubernetes

kubectl apply -f k8s/deployment.yaml
kubectl apply -f k8s/service.yaml

---

📝 Logs y Monitoreo

Ver Logs

tail -f logs/terminato.log

Monitoreo con Prometheus

# Métricas disponibles en /metrics
curl http://localhost:8000/metrics

Integración con Weights & Biases

import wandb
from terminato import TrainingManager

wandb.init(project="terminato")
trainer = TrainingManager(device, use_wandb=True)

---

🆘 Solución de Problemas

CUDA out of memory

trainer.start_training(session_id, batch_size=8)

GPU no detectada

nvidia-smi
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

NVMe no montado

sudo mount /dev/nvme0n1p1 /mnt/nvme0

Puerto 8000 en uso

python -m uvicorn terminato.api.app:app --port 8001

---

📚 Documentación

• README.md - Este archivo
• MANUAL_USUARIO.md - Guía completa (incluida en el repositorio)
• API Docs - http://localhost:8000/docs
• GitHub Wiki - https://github.com/yoqer/Terminato/wiki

---

📦 Dependencias Principales

• torch >= 2.0.0 - Deep Learning
• transformers >= 4.30.0 - Modelos pre-entrenados
• fastapi >= 0.100.0 - Framework web
• uvicorn >= 0.23.0 - Servidor ASGI
• pydantic >= 2.0.0 - Validación de datos
• numpy >= 1.24.0 - Computación numérica

---

📄 Licencia

MIT License - Ver LICENSE para detalles

---

🤝 Contribuciones

Las contribuciones son bienvenidas. Por favor:

1. Fork el repositorio
2. Crea una rama para tu feature (git checkout -b feature/AmazingFeature)
3. Commit tus cambios (git commit -m 'Add some AmazingFeature')
4. Push a la rama (git push origin feature/AmazingFeature)
5. Abre un Pull Request

---

📞 Soporte

• Documentación: https://github.com/yoqer/Terminato/wiki
• Issues: https://github.com/yoqer/Terminato/issues
• Discussions: https://github.com/yoqer/Terminato/discussions
• API Docs: http://localhost:8000/docs

---

🙏 Agradecimientos

Agradecemos a la comunidad de código abierto por las librerías utilizadas:

• PyTorch
• Transformers
• FastAPI
• Uvicorn
• Pydantic

---

Terminato v1.0.0 - Framework de Entrenamiento Dirigido
Última Actualización: 4 de Marzo de 2026
Estado: Listo para Producción ✅