Red Neuronal Convolucional - Experimentación y Análisis

Proyecto Profesional de Ingeniería de Datos

Este notebook demuestra cómo usar el proyecto modular para entrenar y evaluar modelos CNN.

1. Setup Inicial

import sys
from pathlib import Path

# Agregar raíz del proyecto al path
project_root = Path.cwd()
sys.path.insert(0, str(project_root))

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

print(f"TensorFlow versión: {tf.__version__}")
print(f"Proyecto raíz: {project_root}")

2. Importar Módulos del Proyecto

from src.config import mnist_config, cats_dogs_config
from src.data import MNISTDataLoader, CatsVsDogsDataLoader
from src.models import build_mnist_model, build_cats_dogs_model, ModelTrainer
from src.utils import setup_logging, Visualizer, MetricsCalculator

# Configurar logging
logger = setup_logging(mnist_config)
logger.info("Módulos del proyecto importados exitosamente")

3. Exploración de MNIST

# Cargar datos MNIST
logger.info("Cargando dataset MNIST...")
data_loader = MNISTDataLoader(batch_size=32)
train_data, test_data, metadata = data_loader.load()

logger.info(f"Classes: {metadata.features['label'].names}")
logger.info(f"Dataset cargado exitosamente")

# Visualizar algunas muestras de MNIST
plt.figure(figsize=(12, 4))

for i, (imagenes, etiquetas) in enumerate(train_data.take(1)):
    for j in range(min(10, len(imagenes))):
        plt.subplot(1, 10, j + 1)
        plt.imshow(imagenes[j].numpy().squeeze(), cmap='gray')
        plt.title(str(etiquetas[j].numpy().item()))
        plt.axis('off')

plt.suptitle('Muestras MNIST')
plt.tight_layout()
plt.show()

4. Construcción y Visualización de Modelo MNIST

# Construir modelo
logger.info("Construyendo modelo MNIST...")
model_mnist = build_mnist_model(mnist_config)

# Mostrar arquitectura
logger.info("Arquitectura del modelo:")
model_mnist.summary()

# Contar parámetros
total_params = model_mnist.count_params()
trainable_params = sum([tf.size(w).numpy() for w in model_mnist.trainable_weights])

print(f"\nTotal de parámetros: {total_params:,}")
print(f"Parámetros entrenables: {trainable_params:,}")

5. Comparación de Configuraciones

# Mostrar configuraciones
import json

print("\n=== CONFIGURACIÓN MNIST ===")
print(f"Image shape: {mnist_config.image_shape}")
print(f"Batch size: {mnist_config.batch_size}")
print(f"Epochs: {mnist_config.epochs}")
print(f"Learning rate: {mnist_config.learning_rate}")
print(f"Dropout: {mnist_config.dropout_rate}")

print("\n=== CONFIGURACIÓN CATS VS DOGS ===")
print(f"Image shape: {cats_dogs_config.image_shape}")
print(f"Batch size: {cats_dogs_config.batch_size}")
print(f"Epochs: {cats_dogs_config.epochs}")
print(f"Learning rate: {cats_dogs_config.learning_rate}")
print(f"Dropout: {cats_dogs_config.dropout_rate}")
print(f"Early stopping patience: {cats_dogs_config.early_stopping_patience}")

6. Testing de Arquitectura

# Test predicción con entrada dummy
dummy_input = np.random.randn(1, 28, 28, 1).astype(np.float32)
output = model_mnist(dummy_input)

print(f"Input shape: {dummy_input.shape}")
print(f"Output shape: {output.shape}")
print(f"Output probabilities: {output[0].numpy()}")
print(f"Predicción: {np.argmax(output[0])}")

7. Análisis de Rutas y Configuración

from src.config import Config

# Mostrar rutas configuradas
print("=== RUTAS DEL PROYECTO ===")
print(f"Project root: {mnist_config.project_root}")
print(f"Data dir: {mnist_config.data_dir}")
print(f"Models dir: {mnist_config.models_dir}")
print(f"Logs dir: {mnist_config.logs_dir}")

# Verificar existencia
print("\n=== DIRECTORIOS EXISTENTES ===")
print(f"Data dir existe: {mnist_config.data_dir.exists()}")
print(f"Models dir existe: {mnist_config.models_dir.exists()}")
print(f"Logs dir existe: {mnist_config.logs_dir.exists()}")

8. Recursos Disponibles

# Información del sistema
print("=== INFORMACIÓN DEL SISTEMA ===")
print(f"GPUs disponibles: {len(tf.config.list_physical_devices('GPU'))}")
print(f"CPUs disponibles: {len(tf.config.list_physical_devices('CPU'))}")

# Si hay GPU
gpus = tf.config.list_physical_devices('GPU')
if gpus:
    print(f"\nDetalles GPU:")
    for gpu in gpus:
        print(f"  - {gpu.name}")

9. Próximos Pasos

Para entrenar los modelos, ejecutar desde terminal:

# Entrenar MNIST
python -m scripts.train_mnist

# Entrenar Cats vs Dogs
python -m scripts.train_cats_dogs

# Realizar predicciones
python -m scripts.predict --model mnist --image ruta/imagen.png

O usar el Makefile:

make train-all      # Entrena ambos modelos
make help          # Ver todos los comandos