Taller Docker
馃懃 Integrantes:
- 馃懁 Daniel Sarmiento
- 馃懁 Redactor: Jorge Garcia
馃搼 Material de apoyo:
- 馃搳 Diapositivas: Ver presentaciones
Uso de Docker para Modelos de Inteligencia Artificial
Docker ha transformado la manera en que desarrollamos, compartimos y desplegamos aplicaciones. Gracias a su arquitectura basada en contenedores, es posible empaquetar entornos completos de forma reproducible, segura y portable.
En el campo de la inteligencia artificial (IA), esto resulta especialmente 煤til: podemos aislar modelos, dependencias y configuraciones, evitando conflictos y garantizando resultados consistentes entre equipos y entornos.
En este art铆culo exploraremos c贸mo usar Docker para proyectos de IA, desde su instalaci贸n hasta el despliegue de modelos en contenedores ligeros con soporte para entrenamiento, prueba y monitoreo con TensorBoard.
1. Introducci贸n a Docker
Docker es una plataforma de contenedorizaci贸n que permite ejecutar aplicaciones dentro de entornos aislados denominados containers.
Cada contenedor incluye el c贸digo, las dependencias y configuraciones necesarias, asegurando que el comportamiento de la aplicaci贸n sea id茅ntico sin importar el sistema donde se ejecute.
En la ilustraci贸n se observa que las VMs requieren un sistema operativo completo dentro del host, mientras que los contenedores comparten el mismo kernel. Esto permite que un contenedor arranque en segundos y consuma una fracci贸n de los recursos.
2. Instalaci贸n de Docker
La instalaci贸n de Docker var铆a seg煤n la distribuci贸n o sistema operativo.
A continuaci贸n, se muestran los m茅todos m谩s comunes:
Linux
Arch Linux / Manjaro
sudo pacman -S docker
sudo systemctl enable --now docker
Ubuntu / Debian
sudo apt update
sudo apt install docker.io -y
sudo systemctl enable --now docker
Fedora
sudo dnf install docker -y
sudo systemctl enable --now docker
Una vez instalado, puedes verificar su funcionamiento con:
docker run hello-world
Windows y macOS
Docker ofrece una aplicaci贸n oficial llamada Docker Desktop, que integra todas las herramientas necesarias. Puede descargarse desde el sitio oficial: 馃憠 https://www.docker.com/products/docker-desktop
3. Comandos b谩sicos de Docker
| Comando | Descripci贸n |
|---|---|
docker ps -a |
Muestra todos los contenedores (incluidos los detenidos) |
docker pull <imagen> |
Descarga una imagen desde un registro (por ejemplo, Docker Hub) |
docker run <imagen> |
Ejecuta una imagen en un nuevo contenedor |
docker images |
Lista las im谩genes disponibles en el sistema |
docker rm <id> |
Elimina un contenedor |
docker rmi <id> |
Elimina una imagen |
docker exec -it <nombre> bash |
Abre una sesi贸n interactiva dentro de un contenedor |
4. Estructura b谩sica de un Dockerfile
Para construir una imagen personalizada, se utiliza un archivo llamado Dockerfile.
Este define los pasos necesarios para preparar el entorno de ejecuci贸n.
Ejemplo simple:
FROM docker.io/postgres:latest # Imagen base
RUN apt update && apt upgrade -y
ENV POSTGRES_USER=user \
POSTGRES_PASSWORD=password \
POSTGRES_DB=exampledb
Cada instrucci贸n genera una capa (layer), lo que permite que las reconstrucciones sean m谩s r谩pidas y eficientes.
5. Contenerizando un Modelo de IA con PyTorch
Imaginemos que queremos crear un contenedor para entrenar un modelo convolucional sencillo en el dataset CIFAR-10. El modelo en PyTorch podr铆a ser el siguiente:
import torch.nn as nn
import torch.nn.functional as F
import torch
class Net(nn.Module):
def __init__(self, dropout_rate=0.3):
super().__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
self.dropout = nn.Dropout(dropout_rate)
self._initialize_weights()
def _initialize_weights(self):
for m in self.modules():
if isinstance(m, (nn.Conv2d, nn.Linear)):
nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
if m.bias is not None:
nn.init.constant_(m.bias, 0)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = torch.flatten(x, 1)
x = F.relu(self.fc1(x))
x = self.dropout(F.relu(self.fc2(x)))
x = self.fc3(x)
return x
Para contenerizarlo, creamos un Dockerfile como este:
# Imagen base ligera con Python
FROM python:3.12-slim
# Directorio de trabajo
WORKDIR /app
# Copiar el c贸digo fuente
COPY . /app
# Instalar dependencias (CPU-only)
RUN pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu
RUN pip install matplotlib scikit-learn albumentations tqdm tensorboard
# Instalar dependencias adicionales (si existen)
RUN if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
# Variables de entorno
ENV PYTHONUNBUFFERED=1
ENV PYTHONDONTWRITEBYTECODE=1
# Comando por defecto
CMD ["python", "train.py"]
馃挕 Si cuentas con GPU y drivers CUDA, puedes usar una imagen base con soporte GPU, como:
FROM pytorch/pytorch:2.2.0-cuda12.1-cudnn8-runtime
6. Orquestaci贸n con Docker Compose
En proyectos de IA es habitual tener m煤ltiples tareas: entrenamiento, evaluaci贸n y monitoreo.
Con Docker Compose podemos definir todos los servicios en un solo archivo docker-compose.yml:
version: '3.9'
services:
train:
build:
context: .
dockerfile: Dockerfile
image: pytorch-uv-app:latest
container_name: pytorch-train
command: python train.py
volumes:
- ./data:/app/data
- ./model:/app/model
- ./runs:/app/runs
- ./checkpoints:/app/checkpoints
restart: "no"
test:
image: pytorch-uv-app:latest
container_name: pytorch-test
command: python test.py
volumes:
- ./data:/app/data
- ./model:/app/model
- ./runs:/app/runs
- ./checkpoints:/app/checkpoints
restart: "no"
tensorboard:
image: python:3.12-slim
container_name: pytorch-tensorboard
command: >
sh -c "pip install --quiet tensorboard>=2.20.0 &&
tensorboard --logdir=/app/runs --host=0.0.0.0 --port=6006"
ports:
- "6006:6006"
volumes:
- ./runs:/app/runs
restart: unless-stopped
profiles:
- monitoring
Ejecuci贸n
Ejecutar el entrenamiento:
docker compose up train
Ejecutar las pruebas:
docker compose up test
Iniciar TensorBoard para monitoreo:
docker compose --profile monitoring up tensorboard
Luego, accede a http://localhost:6006 para visualizar las m茅tricas.
7. Conclusiones
El uso de Docker en proyectos de IA ofrece ventajas notables:
- Reproducibilidad: garantiza que los experimentos sean consistentes entre m谩quinas.
- Portabilidad: los modelos pueden ejecutarse en cualquier entorno con Docker.
- Aislamiento: elimina conflictos de dependencias entre proyectos.
- Escalabilidad: simplifica el despliegue en servidores, clusters o la nube.
- Integraci贸n continua: facilita pipelines de entrenamiento y validaci贸n automatizados.
En definitiva, Docker se ha convertido en una herramienta esencial en el ciclo de vida de los modelos de inteligencia artificial, desde su desarrollo hasta su puesta en producci贸n.
馃摌 Recursos adicionales: