Mejores Prácticas de Aprendizaje Profundo

Reglas para el entrenamiento y despliegue reproducible y eficiente de PyTorch. Aplicar durante la revisión de código y antes de escalar a multi-GPU.

Cómo Usar Esta Lista

• Las Reglas A-B cubren la configuración y los pipelines de datos.
• Las Reglas C-D rigen el entrenamiento y la evaluación.
• Las Reglas E-F cubren la exportación y la producción.
• Revisar al cambiar hardware, versión del framework o arquitectura del modelo.

A - Reproducibilidad

• Establecer semillas aleatorias. torch.manual_seed(42), np.random.seed(42) y el generator de DataLoader para ejecuciones reproducibles.
• Fijar versiones de PyTorch y CUDA. Registrar torch.__version__ y el driver de CUDA en los logs del experimento.
• Guardar hiperparámetros con los checkpoints. Incluir LR, tamaño de lote, configuración de arquitectura y versión del dataset.
• Usar flags deterministas al depurar. torch.use_deterministic_algorithms(True) para reproducibilidad (puede reducir el rendimiento).

B - Pipeline de Datos

• Separar transformaciones de entrenamiento y validación. Aumentos aleatorios solo en entrenamiento; transformaciones deterministas en validación/prueba.
• Usar pin_memory y non_blocking con CUDA. Superponer la transferencia de datos con la computación de la GPU.
• Establecer num_workers apropiadamente. 4-8 workers en máquinas multi-núcleo; 0 en notebooks.
• Validar un solo lote antes de entrenar. Imprimir formas, tipos de datos y rangos de valores para detectar errores en el pipeline tempranamente.

C - Entrenamiento

• Llamar model.train() y model.eval() correctamente. Dropout y batch norm dependen del modo.
• Usar zero_grad(set_to_none=True) antes de backward. Previene errores de acumulación de gradientes.
• Recortar gradientes para RNNs y redes profundas. clip_grad_norm_(model.parameters(), 1.0).
• Usar precisión mixta en CUDA. torch.amp.autocast + GradScaler para una aceleración 2x.
• Guardar checkpoints en mejoras de validación. No guardar solo la última época.
• Monitorizar métricas de validación cada época. La pérdida de entrenamiento por sí sola oculta el sobreajuste.

D - Diseño del Modelo

• Empezar desde pesos preentrenados cuando los datos son limitados. ImageNet para visión, HF hub para NLP.
• Usar tasas de aprendizaje diferenciales para el ajuste fino. LR más bajo para capas preentrenadas, más alto para la nueva cabeza.
• Emparejar la función de pérdida con la tarea. CrossEntropyLoss para multi-clase; BCEWithLogitsLoss para multi-etiqueta.
• Perfilar antes de optimizar. Identificar si la carga de datos o la computación de la GPU es el cuello de botella.

E - Checkpointing y Exportación

• Guardar state_dict, no objetos completos del modelo. Reconstruir la clase del modelo al cargar.
• Usar weights_only=True al cargar checkpoints. Mejor práctica de seguridad de PyTorch 2.6+.
• Exportar en modo eval. model.eval() antes de trazar TorchScript o exportar ONNX.
• Verificar que la salida del modelo exportado coincide con PyTorch. torch.allclose contra la salida de ONNX Runtime.

F - Producción

• Versionar artefactos del modelo en un registro. Vincular cada artefacto al hash de los datos de entrenamiento y las métricas.
• Incluir el esquema de entrada en el contrato de servicio. Forma del tensor esperada, tipo de datos y normalización.
• Probar la latencia y memoria de inferencia. Perfilar los tamaños de lote esperados en producción.
• Planificar el costo de la GPU. Usar instancias spot, precisión mixta y modelos del tamaño adecuado.

Preguntas Frecuentes

torch.manual_seed(42)
torch.cuda.manual_seed_all(42)
generator = torch.Generator().manual_seed(42)
loader = DataLoader(ds, generator=generator, shuffle=True)

def test_model_output_shape():
    out = model(torch.randn(1, 3, 224, 224))
    assert out.shape == (1, num_classes)

Relacionado

• Training Loops - implementación del bucle
• GPUs & Mixed Precision - configuración de AMP
• Saving, Loading & Export - formato de artefactos
• Experiment Tracking - registro de ejecuciones
• Distributed Training - escalado horizontal

Versiones de la pila: Esta página fue escrita para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, y uv 0.6+.