Notas de Ollama Multi-GPU: agrupación de VRAM, selección de GPU y malentendidos comunes

Sun, 19 Apr 2026 00:18:00 +0800

Al ejecutar la inferencia local con Ollama, surgen rápidamente algunas preguntas: si ya tengo una GPU y mi placa base todavía tiene ranuras PCIe vacías, ¿ayuda agregar más GPU? ¿Es necesario que las GPU sean idénticas? ¿Se puede combinar VRAM? ¿Acelerará la inferencia como un marco de entrenamiento de múltiples GPU?

Esta nota resume cómo se comporta Ollama con múltiples GPU. La versión corta:

Ollama admite múltiples GPU.
El valor principal de varias GPU generalmente es adaptar modelos más grandes a la VRAM disponible, sin obtener un escalado lineal de tokens.
De forma predeterminada, si un modelo cabe completamente en una GPU, Ollama tiende a cargarlo en una sola GPU.
Si un modelo no cabe en una GPU, Ollama puede distribuirlo entre las GPU disponibles.
Ollama puede ver modelos de GPU mixtos, pero el rendimiento y la ubicación pueden no ser los ideales.
SLI/NVLink no es necesario para el uso de múltiples GPU.
Para limitar qué GPU puede usar Ollama, use CUDA_VISIBLE_DEVICES, ROCR_VISIBLE_DEVICES o GGML_VK_VISIBLE_DEVICES.

Comportamiento oficial: GPU única primero, GPU múltiple cuando sea necesario

Las preguntas frecuentes de Ollama describen directamente la lógica de carga de múltiples GPU: al cargar un nuevo modelo, Ollama estima la VRAM requerida y la compara con la memoria de GPU disponible actualmente. Si el modelo cabe completamente en una GPU, carga el modelo en esa GPU. Si no cabe en una sola GPU, el modelo se distribuye entre todas las GPU disponibles.

La razón es el rendimiento. Mantener un modelo en una GPU generalmente reduce las transferencias de datos a través del bus PCIe durante la inferencia, por lo que suele ser más rápido.

Así que no pienses en Ollama multi-GPU como si “más tarjetas significan automáticamente varias veces más rápido”. Un modelo más preciso es:

El modelo pequeño cabe en una GPU: normalmente funciona con una GPU.
El modelo grande no cabe en una GPU: se divide en varias GPU.
Todavía no hay suficiente VRAM: parte del modelo vuelve a la memoria del sistema y la velocidad cae notablemente.

Utilice este comando para ver dónde está cargado el modelo:

`1`	`ollama ps`

La columna “PROCESADOR” puede mostrar algo como:

1
2
3

100% GPU
48%/52% CPU/GPU
100% CPU

Si ve “48%/52% CPU/GPU”, parte del modelo ya está en la memoria del sistema. En ese caso, agregar más memoria GPU o usar una GPU con VRAM más grande suele ser más útil que seguir dependiendo de la CPU/RAM.

Multi-GPU no es un simple apilamiento informático

La inferencia LLM local no es lo mismo que SLI en los juegos. Con Ollama en múltiples GPU, el patrón común es que se colocan diferentes capas o tensores en diferentes dispositivos. Esto puede hacer que un modelo más grande encaje en la VRAM disponible combinada, pero es posible que aún sea necesario que los datos se muevan entre dispositivos durante la inferencia.

Por lo tanto, los beneficios de múltiples GPU generalmente se dividen en dos categorías:

Beneficio de VRAM: los modelos más grandes encajan más fácilmente, o menos parte del modelo recurre a CPU/RAM.
Beneficio de rendimiento: generalmente es más obvio cuando un modelo no cabría en una GPU o se extendería en gran medida a la CPU.

Si un modelo 8B o 14B ya cabe por completo en un solo RTX 3090, forzarlo en dos GPU puede no ser más rápido. Incluso puede ralentizarse debido a la sobrecarga de transferencia entre GPU. La estrategia predeterminada de Ollama de “usar una GPU cuando sea necesario” evita ese costo innecesario de PCIe.

No se requiere SLI o NVLink

Ollama multi-GPU no depende de SLI. Se pueden programar varias GPU PCIe normales siempre que el controlador y Ollama puedan detectarlas. NVLink o un ancho de banda PCIe superior puede ayudar en algunos escenarios entre GPU, pero no es un requisito. Muchos servidores y estaciones de trabajo GPU usados pueden ejecutar varias GPU a través de PCIe normal.

A lo que debes prestar atención es al ancho de banda PCIe. La diferencia entre x1, x4, x8 y x16 afecta la rapidez con la que se carga un modelo en VRAM. Si cambia con frecuencia de modelo grande, el ancho de banda PCIe se vuelve más importante. Después de cargar un modelo, PCIe generalmente importa menos durante la generación, pero la división entre GPU aún puede agregar gastos generales.

Reglas más seguras:

Prefiere las bandas x16/x8 a las bandas x1 estilo minería.
El ancho de banda PCIe es más importante cuando se cambian modelos grandes con frecuencia.
Si un modelo permanece residente en VRAM durante mucho tiempo, el ancho de banda PCIe es menos visible.
Para máquinas con múltiples GPU, verifique la topología PCIe de la placa base y los carriles conectados a la CPU.

Limite las GPU NVIDIA que utiliza Ollama

En sistemas NVIDIA con múltiples GPU, use CUDA_VISIBLE_DEVICES para controlar qué GPU puede ver Ollama.

Ejecución temporal:

`1`	`CUDA_VISIBLE_DEVICES=0,1 ollama serve`

Utilice sólo la segunda GPU:

`1`	`CUDA_VISIBLE_DEVICES=1 ollama serve`

Obligar a Ollama a no utilizar GPU NVIDIA:

`1`	`CUDA_VISIBLE_DEVICES=-1 ollama serve`

Los documentos oficiales señalan que los ID numéricos pueden cambiar de orden, por lo que los UUID de GPU son más confiables. Primero verifique los UUID:

`1`	`nvidia-smi -L`

Salida de ejemplo:

1
2

GPU 0: NVIDIA GeForce RTX 3090 (UUID: GPU-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
GPU 1: NVIDIA GeForce RTX 3070 (UUID: GPU-yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy)

Luego especifique el UUID:

`1`	`CUDA_VISIBLE_DEVICES=GPU-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx ollama serve`

Si Ollama está instalado como un servicio systemd de Linux, coloque la variable en el entorno del servicio:

`1`	`sudo systemctl edit ollama.service`

Agregar:

1
2

[Service]
Environment="CUDA_VISIBLE_DEVICES=0,1"

Recargar y reiniciar:

1
2

sudo systemctl daemon-reload
sudo systemctl restart ollama

Selección de dispositivos AMD y Vulkan

Para AMD ROCm, use ROCR_VISIBLE_DEVICES para controlar las GPU visibles:

`1`	`ROCR_VISIBLE_DEVICES=0,1 ollama serve`

Para obligar a Ollama a no usar GPU ROCm, use una identificación no válida:

`1`	`ROCR_VISIBLE_DEVICES=-1 ollama serve`

Los documentos de GPU de Ollama también mencionan el soporte experimental de Vulkan. Para GPU Vulkan, use GGML_VK_VISIBLE_DEVICES:

`1`	`OLLAMA_VULKAN=1 GGML_VK_VISIBLE_DEVICES=0 ollama serve`

Si los dispositivos Vulkan causan problemas, desactívelos:

`1`	`GGML_VK_VISIBLE_DEVICES=-1 ollama serve`

Es más probable que las configuraciones de múltiples GPU de AMD tengan problemas de compatibilidad con el controlador, la versión ROCm y la versión GFX. Los documentos oficiales también mencionan los requisitos del controlador ROCm de Linux y las anulaciones de compatibilidad, como HSA_OVERRIDE_GFX_VERSION. Si combina diferentes generaciones de GPU AMD, primero verifique que cada tarjeta funcione por sí sola antes de probar con varias GPU.

Exponer varias GPU en Docker

Si ejecuta Ollama en Docker, las configuraciones de NVIDIA generalmente requieren nvidia-container-toolkit y luego --gpus para exponer los dispositivos.

Exponga todas las GPU:

docker run -d \
  --gpus=all \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

Exponer GPU específicas:

docker run -d \
  --gpus '"device=0,1"' \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

También puedes combinar esto con variables de entorno:

docker run -d \
  --gpus=all \
  -e CUDA_VISIBLE_DEVICES=0,1 \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

Si nvidia-smi no puede ver las GPU dentro del contenedor, Ollama tampoco puede usarlas. Primero solucione los problemas de transferencia de GPU de Docker y luego Ollama.

¿Qué es `OLLAMA_SCHED_SPREAD`?

En algunas discusiones sobre configuración de múltiples GPU, es posible que vea OLLAMA_SCHED_SPREAD=1 o OLLAMA_SCHED_SPREAD=true. Está relacionado con el programador de Ollama y se usa a menudo cuando las personas desean que los modelos o solicitudes se distribuyan más ampliamente entre las GPU.

Ejemplo:

`1`	`OLLAMA_SCHED_SPREAD=1 ollama serve`

O con systemd:

1
2

[Service]
Environment="OLLAMA_SCHED_SPREAD=true"

Pero no es un cambio mágico. Habilitarlo no implica un escalado lineal de tokens y aún puede ejecutarse en OOM cuando se cargan varios modelos, las estimaciones de VRAM son ajustadas, la longitud del contexto aumenta o la caché KV se expande. El comportamiento principal de las preguntas frecuentes todavía se aplica: si una GPU puede contener completamente el modelo, una GPU suele ser más eficiente; Si una GPU no puede contenerlo, entonces resulta útil la división entre varias GPU. Trate OLLAMA_SCHED_SPREAD como un experimento de programación avanzada, no como una configuración multi-GPU requerida. Primero, comprenda el comportamiento predeterminado y luego ajústelo según ollama ps, registros y nvidia-smi.

Cómo comprobar si se están utilizando varias GPU

Comandos útiles:

`1`	`ollama ps`

`1`	`watch -n 0.5 nvidia-smi`

Ver los registros del servicio de Ollama:

`1`	`journalctl -u ollama -f`

Si usa Docker:

`1`	`docker logs -f ollama`

Esté atento a:

Si Ollama descubre GPU compatibles.
Si el modelo muestra “100% GPU” o una división CPU/GPU.
Si cada GPU tiene VRAM asignada.
Si la VRAM crece en varias GPU durante la carga del modelo.
Si los tokens de generación mejoran en comparación con el desbordamiento de CPU/RAM.
Si la descarga de OOM o de modelos ocurre con frecuencia.

La utilización de la GPU por sí sola puede resultar engañosa. La inferencia LLM no siempre mantiene las GPU completamente cargadas, especialmente con varias GPU, tamaños de lote bajos, contextos pequeños, CPU lentas o enlaces PCIe lentos.

Malentendidos comunes

Malentendido 1: Dos GPU de 12 GB equivalen a una GPU de 24 GB

No exactamente. Varias GPU pueden colocar un modelo en varios dispositivos, pero el acceso entre dispositivos tiene una sobrecarga. Resuelve el problema de “no encaja”, pero no es equivalente a la velocidad y estabilidad de una GPU de gran VRAM.

Malentendido 2: No se pueden mezclar diferentes modelos de GPU

No necesariamente. Si el controlador, la capacidad informática y las bibliotecas de tiempo de ejecución son compatibles con las tarjetas, Ollama puede ver varias GPU. Pero las configuraciones mixtas suelen estar limitadas por una tarjeta más lenta, una VRAM más pequeña y una topología PCIe. La configuración más predecible sigue siendo el mismo modelo, el mismo tamaño de VRAM y controladores de la misma generación con buen soporte.

Malentendido 3: La GPU múltiple siempre es más rápida que la GPU única

No siempre. Si el modelo se adapta completamente a una GPU rápida, una GPU única puede ser más rápida. La GPU múltiple es útil principalmente para modelos grandes, contextos prolongados o VRAM de GPU única insuficiente.

Malentendido 4: Se requiere NVLink / SLI

No. Ollama puede utilizar sistemas PCIe múltiples-GPU ordinarios. NVLink no es un requisito previo.

Malentendido 5: Agregar una GPU no requiere reiniciar los servicios

No siempre es cierto. Es posible que sea necesario reiniciar los servicios systemd de Linux, las aplicaciones en segundo plano de Windows y los contenedores Docker antes de que redescubran dispositivos y variables de entorno.

Sugerencias de selección de GPU

Para la inferencia local de Ollama, la prioridad aproximada es:

La VRAM de una sola GPU más grande suele ser más fácil de administrar.
Las GPU idénticas son más fáciles de solucionar que las GPU mixtas.
Los carriles PCIe más completos facilitan la carga de modelos grandes.
Primero se debe verificar la capacidad de computación CUDA o la compatibilidad con ROCm en las tarjetas más antiguas.
La alimentación, la refrigeración y el flujo de aire del chasis de varias GPU deben planificarse con antelación.

Para plataformas económicas de segunda mano:

Dual RTX 3090 sigue siendo una opción común de alta VRAM.
Las tarjetas Tesla más antiguas, como la P40/M40, tienen una gran VRAM, pero la potencia, la refrigeración, la compatibilidad con el controlador y el rendimiento necesitan compensaciones.
Las tarjetas como RTX 4070/4070 Ti tienen buena eficiencia, pero la VRAM de una sola tarjeta puede ser limitante.
Puede ser divertido experimentar con varias tarjetas antiguas de 8 GB, pero no son ideales para ejecutar modelos grandes a largo plazo.

Resumen

La compatibilidad con múltiples GPU de Ollama se entiende mejor como “primero la expansión de VRAM y luego la aceleración del rendimiento”. Si el modelo cabe completamente en una GPU, la ruta predeterminada de una sola GPU suele ser más rápida. Si una GPU no puede contenerlo, varias GPU pueden distribuir el modelo entre dispositivos y evitar un gran desbordamiento de CPU/RAM, lo que hace que se puedan utilizar modelos más grandes.

En la práctica, use ollama ps para verificar dónde está cargado el modelo, luego use las herramientas nvidia-smi o ROCm para observar la asignación de VRAM. Para la selección de GPU, use CUDA_VISIBLE_DEVICES en NVIDIA, ROCR_VISIBLE_DEVICES en AMD ROCm y GGML_VK_VISIBLE_DEVICES para Vulkan. Si se ejecuta en Docker, primero asegúrese de que el contenedor pueda ver las GPU.

La multi-GPU no es mágica. Puede ayudar a adaptar modelos más grandes, pero no garantiza una aceleración lineal. La ruta estable sigue siendo preferir GPU únicas con gran VRAM o configuraciones idénticas de múltiples GPU, considerando al mismo tiempo la compatibilidad con controladores, PCIe, alimentación, refrigeración y cuantificación de modelos.

Referencias

Preguntas frecuentes de Ollama: ¿Cómo carga Ollama modelos en múltiples GPU?: https://github.com/ollama/ollama/blob/main/docs/faq.mdx
Documentos de Ollama GPU: soporte de hardware/selección de GPU: https://github.com/ollama/ollama/blob/main/docs/gpu.mdx
Centro Docker de Ollama: https://hub.docker.com/r/ollama/ollama
Kit de herramientas de contenedor NVIDIA: https://github.com/NVIDIA/nvidia-container-toolkit

LLM Locales on KnightLi Blog