Skip to main content

Taller Docker

馃懃 Integrantes:

  • 馃懁 Daniel Sarmiento
  • 馃懁 Redactor: Jorge Garcia

馃搼 Material de apoyo:

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.

Aunque a menudo se compara con una m谩quina virtual (VM), Docker no virtualiza hardware. En cambio, utiliza el kernel del sistema operativo anfitri贸n junto con tecnolog铆as como namespaces y cgroups para aislar procesos, lo que lo hace mucho m谩s liviano y r谩pido.

Comparativa de Container vs Virtual Machine
Comparativa de container vs virtual machine

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:

Back to top