Skip to content

training

Directory actions

More options

Directory actions

More options

Latest commit

 

History

History

training

README.md

Training del Modelo de Profit - Entrenamiento Distribuido con Ray

Este módulo contiene el código para entrenar el modelo de predicción de ganancias usando Ray Train para entrenamiento distribuido y escalable.

📋 Descripción General

El training utiliza:

  • Ray Train: Framework de entrenamiento distribuido
  • PyTorch: Backend de deep learning
  • Red Neuronal: Arquitectura feedforward con dropout
  • Exportación ONNX: Para despliegue en producción

Arquitectura del Modelo

Input (15 features) → Dense(256) → ReLU → Dropout(0.2)
                    → Dense(128) → ReLU → Dropout(0.2)
                    → Dense(64)  → ReLU → Dropout(0.2)
                    → Dense(1)   → Output (profit)

Features de entrada (15):

  • Region, Country, Item_Type, Sales_Channel, Order_Priority (categóricas codificadas)
  • Units_Sold, Unit_Price, Unit_Cost, Total_Revenue, Total_Cost (numéricas normalizadas)
  • Order_Year, Order_Month, Order_Day, Order_DayOfWeek, Days_to_Ship (temporales derivadas)

📦 Obtención de Datos

Los datos NO están incluidos en este repositorio. Debes descargarlos desde una fuente externa.

Opción 1: Descargar Dataset de Ventas (Recomendado)

Descarga datos de prueba desde Excel BI Analytics:

Datasets disponibles:

Pasos para descargar:

# 1. Crear directorio de datos
mkdir -p data

# 2. Descargar dataset (ejemplo con 1.5M registros)
cd data
wget https://excelbianalytics.com/wp/wp-content/uploads/2017/07/1500000%20Sales%20Records.zip

# 3. Descomprimir
unzip "1500000 Sales Records.zip"

# 4. Renombrar archivo
mv "1500000 Sales Records.csv" ventas.csv

# 5. Limpiar
rm "1500000 Sales Records.zip"
cd ..

Con curl:

mkdir -p data
curl -L "https://excelbianalytics.com/wp/wp-content/uploads/2017/07/1500000%20Sales%20Records.zip" -o data/sales.zip
unzip data/sales.zip -d data/
mv "data/1500000 Sales Records.csv" data/ventas.csv
rm data/sales.zip

Formato del Dataset

El CSV debe tener las siguientes columnas:

Region,Country,Item Type,Sales Channel,Order Priority,Order Date,Order ID,Ship Date,Units Sold,Unit Price,Unit Cost,Total Revenue,Total Cost,Total Profit
Sub-Saharan Africa,South Africa,Fruits,Offline,M,7/27/2012,443368995,7/28/2012,1593,9.33,6.92,14862.69,11023.56,3839.13
Middle East and North Africa,Morocco,Clothes,Online,M,9/14/2013,667593514,10/19/2013,4611,109.28,35.84,503890.08,165258.24,338631.84
...

Columnas requeridas:

  • Region: Región geográfica
  • Country: País
  • Item Type: Tipo de producto
  • Sales Channel: Canal de ventas (Online/Offline)
  • Order Priority: Prioridad (L/M/H/C)
  • Order Date: Fecha de orden (MM/DD/YYYY)
  • Ship Date: Fecha de envío (MM/DD/YYYY)
  • Units Sold: Unidades vendidas
  • Unit Price: Precio unitario
  • Unit Cost: Costo unitario
  • Total Revenue: Ingresos totales
  • Total Cost: Costo total
  • Total Profit: Ganancia total (target)

📁 Estructura del Módulo

training/
├── __init__.py              # Inicialización del paquete
├── model.py                 # Arquitectura del modelo PyTorch
├── preprocess.py            # Preprocesamiento de datos
├── ray_trainer.py           # Entrenamiento distribuido con Ray ⭐
└── README.md               # Esta documentación

🚀 Instalación

Prerrequisitos

# Python 3.8+
python --version

# Crear entorno virtual
python -m venv venv
source venv/bin/activate  # En Windows: venv\Scripts\activate

Instalar Dependencias

# Dependencias principales
pip install torch torchvision
pip install ray[train]
pip install pandas numpy scikit-learn
pip install onnx onnxruntime

# O desde requirements (si existe)
pip install -r requirements.txt

🎯 Uso Básico

Entrenamiento Simple (Local)

# Desde la carpeta training/
python ray_trainer.py --data-path ../data/ventas.csv --num-workers 2 --epochs 50

Entrenamiento con GPU

python ray_trainer.py \
  --data-path ../data/ventas.csv \
  --num-workers 2 \
  --use-gpu \
  --epochs 100 \
  --batch-size 256

Entrenamiento en Cluster Ray

# 1. Iniciar Ray cluster (en otro terminal)
ray start --head --port=8265

# 2. Entrenar conectándose al cluster
python ray_trainer.py \
  --data-path ../data/ventas.csv \
  --address localhost:8265 \
  --num-workers 4 \
  --epochs 100

🔧 Parámetros de Configuración

Argumentos de Línea de Comandos

python ray_trainer.py [OPTIONS]
Argumento Tipo Default Descripción
--data-path str ../data/ventas.csv Ruta al archivo CSV
--num-workers int 2 Número de workers para entrenamiento distribuido
--use-gpu flag False Activar entrenamiento con GPU
--epochs int 50 Número de épocas de entrenamiento
--batch-size int 128 Tamaño del batch
--address str None Dirección del cluster Ray (e.g., localhost:8265)

Ejemplo Completo

python ray_trainer.py \
  --data-path ../data/ventas.csv \
  --num-workers 4 \
  --use-gpu \
  --epochs 100 \
  --batch-size 256 \
  --address localhost:8265

📊 Salidas del Entrenamiento

El script genera los siguientes archivos:

models/
├── best_model.pth              # Mejor modelo PyTorch
├── best_model_info.json        # Información del entrenamiento
├── model.onnx                  # Modelo exportado a ONNX ⭐
├── model.onnx.data             # Datos del modelo ONNX (si aplica)
└── preprocessing_info.pkl      # Encoders, scalers y metadata ⭐

Archivos para Despliegue

Los archivos marcados con ⭐ son necesarios para el despliegue en producción:

  1. model.onnx: Modelo en formato ONNX para inferencia
  2. preprocessing_info.pkl: Información de preprocesamiento (encoders, scaler, columnas)

Copiar a módulos de despliegue:

# Para Ray Serve
cp models/model.onnx* ../serving/1-ray-serve/models/
cp models/preprocessing_info.pkl ../serving/1-ray-serve/models/

# Para Ray-Triton Separados
cp models/model.onnx* ../serving/3-ray-triton-microservices/model_repository/serving/1/
cp models/preprocessing_info.pkl ../serving/3-ray-triton-microservices/

# Para Triton Server
cp models/model.onnx* ../serving/2-triton-server/model_repository/serving/1/
cp models/preprocessing_info.pkl ../serving/2-triton-server/model_repository/preproc_profit/1/

# Para Ray+Triton Single
cp models/model.onnx* ../serving/4-ray-triton-single/model_repository/serving/1/
cp models/preprocessing_info.pkl ../serving/4-ray-triton-single/model_repository/serving/1/

📈 Monitoreo del Entrenamiento

Durante el Entrenamiento

El script muestra métricas en tiempo real:

🚀 Iniciando entrenamiento distribuido con Ray Train
  • Framework: Ray Train + PyTorch backend
  • Workers: 2
  • GPU: No
  • Épocas: 50
  • Batch size: 128
  • Estrategia: Data Parallel Training

Worker - Época [10/50], Loss Train: 0.0234, Loss Val: 0.0245
Worker - Época [20/50], Loss Train: 0.0198, Loss Val: 0.0201
Worker - Época [30/50], Loss Train: 0.0176, Loss Val: 0.0182
...

✅ Entrenamiento distribuido completado
  • Mejor val_loss: 0.0165
  • Tiempo total: 245.32 segundos

Ray Dashboard

Si usas un cluster Ray, puedes monitorear en el dashboard:

# Dashboard disponible en:
http://localhost:8265

🧪 Uso Programático

En un Script Python

from training_profit.ray_trainer import train_with_ray

# Entrenar modelo
metrics = train_with_ray(
    data_path="../data/ventas.csv",
    num_workers=2,
    use_gpu=False,
    num_epochs=50,
    batch_size=128,
    learning_rate=0.001,
    model_save_path="models/best_model.pth",
    onnx_save_path="models/model.onnx"
)

print(f"R² Score: {metrics['r2']:.4f}")
print(f"MAE: ${metrics['mae']:.2f}")

Personalizar Arquitectura

from training_profit.ray_trainer import RayModelTrainer
from training_profit.preprocess import DataPreprocessor
from sklearn.model_selection import train_test_split

# Preprocesar datos
preprocessor = DataPreprocessor()
X, y, _ = preprocessor.load_and_preprocess("../data/ventas.csv")
preprocessor.save_preprocessing_info("models/preprocessing_info.pkl")

# Split
X_temp, X_test, y_temp, y_test = train_test_split(X, y, test_size=0.1)
X_train, X_val, y_train, y_val = train_test_split(X_temp, y_temp, test_size=0.2)

# Entrenar con arquitectura personalizada
trainer = RayModelTrainer(num_workers=4, use_gpu=True)

result = trainer.train(
    X_train, y_train, X_val, y_val,
    input_size=X.shape[1],
    hidden_sizes=[512, 256, 128, 64],  # Arquitectura más grande
    dropout_rate=0.3,                   # Más dropout
    num_epochs=100,
    batch_size=256,
    learning_rate=0.0005
)

# Guardar modelo
trainer.save_best_model(result, "models/custom_model.pth")

🎓 Pipeline Completo de Training

Flujo de Trabajo

1. Descarga de Datos
   ↓
2. Preprocesamiento
   - Carga de CSV
   - Feature engineering (fechas)
   - Encoding de categóricas
   - Normalización
   ↓
3. Entrenamiento con Ray
   - Data parallel training
   - Multiple workers
   - Checkpointing automático
   ↓
4. Evaluación
   - MSE, MAE, RMSE, R²
   - Test set validation
   ↓
5. Exportación
   - PyTorch (.pth)
   - ONNX (.onnx)
   - Preprocessing info (.pkl)
   ↓
6. Despliegue
   - Copiar a módulos de profit/

🔧 Troubleshooting

Error: "No se encontró el archivo de datos"

# Verificar que el archivo existe
ls -lh ../data/ventas.csv

# Si no existe, descargar
cd data
wget https://excelbianalytics.com/wp/wp-content/uploads/2017/07/1500000%20Sales%20Records.zip
unzip "1500000 Sales Records.zip"
mv "1500000 Sales Records.csv" ventas.csv

Error: "Ray no está instalado"

pip install ray[train]

Error: "Out of Memory"

# Reducir batch size
python ray_trainer.py --batch-size 64

# O reducir workers
python ray_trainer.py --num-workers 1

Entrenamiento muy lento

# Usar GPU si está disponible
python ray_trainer.py --use-gpu

# O aumentar workers (si tienes CPUs disponibles)
python ray_trainer.py --num-workers 4

# Reducir datos para pruebas rápidas
python ray_trainer.py --data-path ../data/ventas_small.csv

📚 Recursos Adicionales

🔗 Ver También

Última actualización: Diciembre 2025