Unsloth Docker: entrenar y ejecutar 500 modelos de IA en local con un comando

Unsloth Docker es la respuesta a uno de los mayores dolores de la IA local: montar el entorno. La imagen oficial del equipo de Unsloth empaqueta el stack de entrenamiento completo en un contenedor, de modo que ejecutar y afinar modelos deja de ser una tarde de errores de dependencias y pasa a ser un comando. Esta es la explicación de qué ofrece la IA local con Unsloth, cómo se usa su interfaz de Unsloth y qué necesitas para que funcione, con las pautas básicas para entrenar modelos de IA en local.

Qué es Unsloth Docker y por qué importa

Si alguna vez has intentado afinar un modelo en tu propio equipo, conoces el ritual: la versión de CUDA tiene que cuadrar con PyTorch, PyTorch con tu controlador, y luego llegan bitsandbytes, xformers, TRL y PEFT, cada uno con su propia oportunidad de romper la instalación. La solución más fiable que conocía mucha gente era reinstalar y probar otra versión.

Unsloth Docker elimina ese paso. En lugar de instalar dependencias, tiras de una imagen preconstruida que ya las trae. La imagen pesa unos 9,2 GB y contiene el stack completo: PyTorch 2.11 sobre CUDA 12.8, Unsloth y unsloth-zoo, bitsandbytes, TRL, PEFT y xformers en linux/amd64. Del lado de la inferencia incluye llama.cpp precompilado, y la última etiqueta añade whisper.cpp para el reconocimiento de voz de Studio.

El respaldo de la comunidad es considerable: la imagen superó las 100.000 descargas acumuladas, con unas 12.000 en la última semana, y sus etiquetas principales se reconstruyen a diario y con cada lanzamiento.

Qué hay dentro de la imagen Docker de Unsloth

La imagen viene en dos sabores, y elegir bien te ahorra tiempo y disco.

Además de esas dos, hay etiquetas nightly con fecha inmutable que se conservan 60 días para entornos reproducibles, y etiquetas fijadas por versión. Las dos principales son multiarquitectura, así que cubren linux/amd64 y linux/arm64, lo que permite usarlas en equipos ARM como el GH200 y el DGX Spark.

AMD tiene su propia imagen, unsloth/unsloth-rocm, una compilación ROCm del mismo stack. Lo curioso es cómo se engancha al hardware: no usa toolkit de contenedores, sino que pasa directamente los nodos de dispositivo del controlador del kernel, así que el comando de arranque cambia un poco respecto al de NVIDIA.

Cómo ejecutar modelos de IA en local con Unsloth

El arranque en NVIDIA es una sola línea. Se lanza desde la carpeta de tu proyecto, porque esa carpeta se convierte en /workspace/host dentro del contenedor. El comando expone el puerto 8000 para Unsloth Studio y el 8888 para JupyterLab, y monta tres volúmenes que conservan tus archivos, los modelos y los datos de Studio.

El requisito de partida es un controlador NVIDIA 570.26 o superior. Si aún no tienes Docker y el NVIDIA Container Toolkit, hay dos comandos de instalación que cubren Ubuntu, Debian, RHEL, Fedora, Rocky, Amazon Linux y SUSE, y comprueban que un contenedor puede ver la GPU. En Windows basta con Docker Desktop con el backend de WSL 2 y un controlador NVIDIA actualizado.

Con el contenedor en marcha, abres localhost:8000 en el navegador. En el primer arranque tendrás que iniciar sesión como unsloth con la contraseña generada, que aparece en los registros del contenedor, y elegir una nueva cuando te lo pida. Si necesitas regenerarla más tarde, hay un comando que la cambia en el sitio sin reiniciar nada.

Qué puedes hacer con Unsloth: chat, entrenamiento e imágenes

La interfaz web de Studio reúne tres flujos en una sola pantalla, y eso es lo que convierte la imagen en algo más que un contenedor de línea de comandos.

Chat. Carga modelos cuantizados en formato GGUF y te marca qué cuantización encaja en tu RAM y tu VRAM, además de avisarte de las variantes que darán problemas de memoria. Puedes buscar directamente en Hugging Face, y las descargas van a una caché local que se comparte con los notebooks, así que nada se baja dos veces.

Entrenamiento. Eliges modelo y método en la pantalla de configuración, coges un dataset de Hugging Face o subes el tuyo, y arrancas. Soporta ajuste fino de texto, visión y audio, además de embeddings y difusión de imágenes, y cada uno de esos flujos desde la misma imagen. Mientras corre, sigues la pérdida y el uso de GPU en vivo, y al terminar puedes comparar en el chat el modelo base con tu versión afinada usando los mismos prompts.

Imágenes. Hay un flujo integrado de texto a imagen, con modelos recomendados como Z-Image-Turbo, además de modos de transformación e inpaint según lo que tengas cargado.

Para quien viene de la línea de comandos, el puerto 8888 sirve un JupyterLab con notebooks de ejemplo agrupados por modelo y tarea, que se refrescan desde GitHub en cada arranque del contenedor. Es el mismo material de siempre, pero sin pelearse con el entorno.

Requisitos, GPU compatibles y seguridad

El abanico de GPU soportadas es amplio: desde Turing (T4, RTX 20) hasta Blackwell (B200, GB200, RTX 50, RTX PRO 6000) con kernels SASS precompilados de sm_70 a sm_120. Un detalle que se pasa por alto: la generación Pascal queda fuera, porque el objetivo precompilado más antiguo es sm_70 y la P100 es sm_60. Si sigues con una tarjeta Pascal, ninguna imagen Docker te va a salvar.

¿Y sin GPU? La imagen latest arranca igual: el chat con modelos GGUF y JupyterLab funcionan bien, pero el entrenamiento no. Es una salida útil si solo quieres probar la interfaz o usar el tooling de GGUF.

El apartado de seguridad de la documentación es sorprendentemente franco, y conviene leerlo. El contenedor se ejecuta como root por defecto. JupyterLab es, en la práctica, una shell completa, así que cualquiera que pueda entrar puede lanzar comandos arbitrarios. Studio y JupyterLab sirven HTTP plano, y los propios documentos avisan de que no los expongas a internet. Y cada valor que pases con la opción -e, contraseñas y tokens incluidos, es legible por quien tenga acceso al demonio de Docker.

Las salidas están previstas. Puedes atar los puertos a 127.0.0.1 y tunelizar por SSH, o activar el modo seguro que sirve Studio solo por un túnel HTTPS de Cloudflare, un modo que falla cerrado: sin túnel, no hay servicio. La contraseña del primer arranque se imprime en los registros, y si nunca la cambias, Studio se apaga solo tras una hora. Otro detalle útil: si detienes el contenedor a mitad de un entrenamiento, Studio guarda un punto de control antes de salir, así que puedes retomarlo la próxima vez.

Preguntas frecuentes sobre Unsloth Docker

¿Necesito Docker Desktop? No. Con Docker CE basta para ejecutar modelos, aunque en Windows sí conviene Docker Desktop con WSL 2.

¿Funciona en Mac? El contenedor está pensado para GPU NVIDIA o AMD. En Mac la alternativa es Unsloth Desktop, la aplicación nativa del mismo equipo, que también cubre MLX y GGUF.

¿Cuánto ocupa? Unos 9,2 GB la imagen, más el espacio de los modelos que descargues, que van a la caché de Hugging Face y pueden sumar varios gigabytes cada uno.

¿Puedo perder mi trabajo si borro el contenedor? No, si usas los volúmenes del arranque rápido. Los modelos quedan en la caché, tus archivos en la carpeta montada y los datos de Studio en su volumen. Solo se pierde lo que escribas dentro del contenedor sin montar nada.

¿Entrena sin GPU? No. La imagen latest arranca sin GPU para inferencia y JupyterLab, pero el entrenamiento requiere tarjeta gráfica compatible.

Cómo dar el primer paso con Unsloth

La barrera de entrada de la IA local se ha movido. Antes exigía saber configurar CUDA; ahora pide un disco grande y una GPU decente. La primera condición costaba paciencia; la segunda, al menos, se resuelve con dinero.

Si vas a empezar, hazlo por el camino largo pero seguro: instala Docker y el toolkit, lanza el contenedor con los volúmenes del arranque rápido y entra en Studio. Elige un modelo pequeño de la lista de recomendados, prueba el chat primero y deja el entrenamiento para cuando te sientas cómodo. Y si expones la interfaz más allá de tu red local, activa el modo seguro antes de abrir puertos, no después.

Unsloth Docker no convierte cualquier máquina en un centro de entrenamiento: convierte una tarde de configuración en un comando. Para quien llevaba tiempo posponiendo el salto a la IA local por el miedo al entorno, ese cambio es, en la práctica, la diferencia entre intentarlo y no intentarlo.