Una de las grandes ventajas de WSL2 es su compatibilidad con contenedores Docker y acceso a la GPU, lo que lo convierte en un entorno ideal para correr flujos de machine learning distribuido desde una única máquina con múltiples contenedores Linux. Esto permite simular ambientes de entrenamiento paralelos, microservicios de inferencia o arquitecturas de orquestación como Ray o Dask desde el entorno Windows, sin necesidad de un clúster real o acceso a la nube.

Este artículo describe cómo configurar y ejecutar cargas distribuidas de ML usando Docker, PyTorch, TensorFlow, y Ray sobre WSL2, aprovechando la integración con NVIDIA GPU y el rendimiento de Linux.

Requisitos Link to heading

  • Windows 11 con WSL2
  • Docker Desktop con soporte WSL2 y GPU habilitado
  • NVIDIA GPU compatible + drivers + WSL CUDA Toolkit
  • Distro Ubuntu en WSL2

Verificar GPU:

nvidia-smi

Verificar Docker:

docker --version
docker info

Paso 1: Crear red de contenedores para ML distribuido Link to heading

docker network create ml-network

Esto permite que contenedores se comuniquen por nombre dentro de la red.

Paso 2: Crear imagen base de entrenamiento con GPU Link to heading

Archivo Dockerfile:

FROM pytorch/pytorch:2.1.0-cuda11.8-cudnn8-runtime

RUN apt update && apt install -y git iputils-ping
RUN pip install ray[default] dask scikit-learn pandas matplotlib

WORKDIR /workspace

Construir imagen:

docker build -t ml-node .

Paso 3: Ejecutar contenedores coordinados (Ray) Link to heading

Iniciar nodo principal:

docker run -it --rm --gpus all --network ml-network --name ray-head ml-node   ray start --head --port=6379

En otra terminal, iniciar un nodo worker:

docker run -it --rm --gpus all --network ml-network --name ray-worker ml-node   ray start --address=ray-head:6379

Validar desde un contenedor:

import ray
ray.init(address='auto')
print(ray.cluster_resources())

Esto habilita paralelismo local real, útil para prototipos, testing o benchmarking.

Paso 4: Alternativa con Dask Link to heading

Dask permite flujos similares con programación paralela y pandas-like API.

from dask.distributed import Client
client = Client("scheduler:8786")

Paso 5: Entrenamiento distribuido con PyTorch o TensorFlow Link to heading

Utilizar torch.distributed o tf.distribute para paralelismo manual o con librerías de alto nivel.

Ejemplo básico con torch.multiprocessing:

import torch.multiprocessing as mp

def train(rank):
    print(f"Proceso {rank} entrenando")

if __name__ == "__main__":
    mp.spawn(train, nprocs=2)

Correr en un contenedor con múltiples procesos o GPUs según configuración.

Casos de uso prácticos Link to heading

  • Simulación de entrenamiento distribuido sin necesidad de Kubernetes
  • Inferencia paralela desde varios servicios contenedorizados
  • Microservicios de ML (FastAPI + modelo) en red local entre contenedores
  • Pruebas de carga con frameworks de orquestación y métricas

Buenas prácticas Link to heading

  • Usar docker-compose para definir múltiples nodos y servicios
  • Configurar volúmenes compartidos con datasets
  • Asegurar exposición de puertos entre servicios
  • Monitorizar con herramientas como Ray Dashboard (--dashboard-host 0.0.0.0)
  • Usar contenedores separados por rol (data ingestion, training, inference)

Conclusión Link to heading

WSL2, combinado con Docker y acceso a GPU, permite ejecutar flujos avanzados de machine learning distribuido desde una sola máquina. Esta capacidad potencia a desarrolladores, científicos de datos y equipos de investigación para testear y escalar soluciones ML de forma local, rápida y segura antes de llevarlas a producción.