Metadata-Version: 2.1
Name: terminato
Version: 1.0.0
Summary: Framework de entrenamiento dirigido con control dinámico de GPU/NVMe y análisis de capas
Home-page: https://github.com/yoqer/Terminato
Author: yoqer
Project-URL: Bug Tracker, https://github.com/yoqer/Terminato/issues
Project-URL: Documentation, https://github.com/yoqer/Terminato/wiki
Project-URL: Source Code, https://github.com/yoqer/Terminato
Project-URL: Discussions, https://github.com/yoqer/Terminato/discussions
Keywords: machine-learning,deep-learning,training,gpu,pytorch,tensorflow,model-fusion,fine-tuning,reinforcement-learning
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Science/Research
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Operating System :: OS Independent
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: torch >=2.0.0
Requires-Dist: transformers >=4.30.0
Requires-Dist: fastapi >=0.100.0
Requires-Dist: uvicorn >=0.23.0
Requires-Dist: pydantic >=2.0.0
Requires-Dist: numpy >=1.24.0
Requires-Dist: pyyaml >=6.0
Provides-Extra: all
Requires-Dist: torch >=2.0.0 ; extra == 'all'
Requires-Dist: tensorflow >=2.12.0 ; extra == 'all'
Requires-Dist: jax >=0.4.0 ; extra == 'all'
Requires-Dist: transformers >=4.30.0 ; extra == 'all'
Requires-Dist: pandas >=1.5.0 ; extra == 'all'
Requires-Dist: scikit-learn >=1.2.0 ; extra == 'all'
Requires-Dist: opencv-python >=4.7.0 ; extra == 'all'
Requires-Dist: librosa >=0.10.0 ; extra == 'all'
Requires-Dist: wandb >=0.14.0 ; extra == 'all'
Requires-Dist: pytest >=7.3.0 ; extra == 'all'
Provides-Extra: audio
Requires-Dist: librosa >=0.10.0 ; extra == 'audio'
Requires-Dist: soundfile >=0.12.0 ; extra == 'audio'
Provides-Extra: data
Requires-Dist: pandas >=1.5.0 ; extra == 'data'
Requires-Dist: scipy >=1.9.0 ; extra == 'data'
Requires-Dist: scikit-learn >=1.2.0 ; extra == 'data'
Provides-Extra: dev
Requires-Dist: pytest >=7.3.0 ; extra == 'dev'
Requires-Dist: pytest-cov >=4.0.0 ; extra == 'dev'
Requires-Dist: pytest-asyncio >=0.21.0 ; extra == 'dev'
Requires-Dist: black >=23.3.0 ; extra == 'dev'
Requires-Dist: flake8 >=6.0.0 ; extra == 'dev'
Requires-Dist: mypy >=1.0.0 ; extra == 'dev'
Requires-Dist: isort >=5.12.0 ; extra == 'dev'
Requires-Dist: pre-commit >=3.3.0 ; extra == 'dev'
Provides-Extra: jax
Requires-Dist: jax >=0.4.0 ; extra == 'jax'
Requires-Dist: jaxlib >=0.4.0 ; extra == 'jax'
Requires-Dist: flax >=0.6.0 ; extra == 'jax'
Provides-Extra: ml-complete
Requires-Dist: torch >=2.0.0 ; extra == 'ml-complete'
Requires-Dist: tensorflow >=2.12.0 ; extra == 'ml-complete'
Requires-Dist: pandas >=1.5.0 ; extra == 'ml-complete'
Requires-Dist: scikit-learn >=1.2.0 ; extra == 'ml-complete'
Requires-Dist: xgboost >=1.7.0 ; extra == 'ml-complete'
Requires-Dist: lightgbm >=3.3.0 ; extra == 'ml-complete'
Provides-Extra: monitoring
Requires-Dist: wandb >=0.14.0 ; extra == 'monitoring'
Requires-Dist: tensorboard >=2.12.0 ; extra == 'monitoring'
Requires-Dist: prometheus-client >=0.16.0 ; extra == 'monitoring'
Provides-Extra: nlp-complete
Requires-Dist: torch >=2.0.0 ; extra == 'nlp-complete'
Requires-Dist: transformers >=4.30.0 ; extra == 'nlp-complete'
Requires-Dist: spacy >=3.5.0 ; extra == 'nlp-complete'
Requires-Dist: nltk >=3.8.0 ; extra == 'nlp-complete'
Provides-Extra: research
Requires-Dist: torch >=2.0.0 ; extra == 'research'
Requires-Dist: tensorflow >=2.12.0 ; extra == 'research'
Requires-Dist: transformers >=4.30.0 ; extra == 'research'
Requires-Dist: wandb >=0.14.0 ; extra == 'research'
Requires-Dist: tensorboard >=2.12.0 ; extra == 'research'
Requires-Dist: jupyter >=1.0.0 ; extra == 'research'
Provides-Extra: storage
Requires-Dist: boto3 >=1.26.0 ; extra == 'storage'
Requires-Dist: paramiko >=2.12.0 ; extra == 'storage'
Provides-Extra: teminador
Requires-Dist: teminador >=1.0.0 ; extra == 'teminador'
Provides-Extra: tenminatorch
Requires-Dist: tenminatorch >=1.0.0 ; extra == 'tenminatorch'
Provides-Extra: tensorflow
Requires-Dist: tensorflow >=2.12.0 ; extra == 'tensorflow'
Requires-Dist: keras >=2.12.0 ; extra == 'tensorflow'
Provides-Extra: terminatodo
Requires-Dist: terminatodo >=2.0.0 ; extra == 'terminatodo'
Provides-Extra: terminator
Requires-Dist: terminator >=1.0.0 ; extra == 'terminator'
Provides-Extra: vision
Requires-Dist: opencv-python >=4.7.0 ; extra == 'vision'
Requires-Dist: pillow >=9.5.0 ; extra == 'vision'
Requires-Dist: scikit-image >=0.20.0 ; extra == 'vision'
Provides-Extra: vision-complete
Requires-Dist: torch >=2.0.0 ; extra == 'vision-complete'
Requires-Dist: torchvision >=0.15.0 ; extra == 'vision-complete'
Requires-Dist: opencv-python >=4.7.0 ; extra == 'vision-complete'
Requires-Dist: pillow >=9.5.0 ; extra == 'vision-complete'
Requires-Dist: scikit-image >=0.20.0 ; extra == 'vision-complete'

# Terminato v1.0.0

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

[![Python 3.10+](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/downloads/)
[![PyPI](https://img.shields.io/badge/PyPI-terminato-brightgreen.svg)](https://pypi.org/project/terminato/)
[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
[![GitHub](https://img.shields.io/badge/GitHub-yoqer/Terminato-black.svg)](https://github.com/yoqer/Terminato)

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](#características)
- [Instalación](#instalación)
- [Uso Rápido](#uso-rápido)
- [API REST](#api-rest)
- [Integración](#integración)
- [Documentación](#documentación)
- [Licencia](#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

```bash
pip install terminato
```

### Instalación con Extras

```bash
# 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

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

### Instalación para Desarrollo

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

---

## 🚀 Uso Rápido

### 1. Iniciar Servidor

```bash
# 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

```python
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

```python
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

```python
# 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

```python
# 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

```python
# 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

```python
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

```python
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

```python
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`:

```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

```python
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

```python
# 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

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

### Producción

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

### Docker

```bash
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

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

---

## 📝 Logs y Monitoreo

### Ver Logs

```bash
tail -f logs/terminato.log
```

### Monitoreo con Prometheus

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

### Integración con Weights & Biases

```python
import wandb
from terminato import TrainingManager

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

---

## 🆘 Solución de Problemas

### CUDA out of memory

```python
trainer.start_training(session_id, batch_size=8)
```

### GPU no detectada

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

### NVMe no montado

```bash
sudo mount /dev/nvme0n1p1 /mnt/nvme0
```

### Puerto 8000 en uso

```bash
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](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 ✅
