Qué es AMD ROCm y cómo instalarlo

Si trabajas con aceleración por GPU para IA o HPC, seguramente ya has oído hablar de ROCm, la plataforma abierta de AMD que permite aprovechar sus tarjetas para cómputo serio en Linux y, cada vez más, también en otros entornos. ROCm nació para integrar CPU y GPU de forma eficiente y resolver cargas reales de cómputo con un enfoque abierto, sin ataduras de licencia.

En los últimos ciclos, AMD ha acelerado el desarrollo: con ROCm 7 han llegado mejoras potentes en rendimiento y compatibilidad, y versiones 6.x previas abrieron la puerta a escenarios como WSL2 y configuraciones multi-GPU. Lo interesante es que ya no hablamos de una demo perpetua, sino de un ecosistema que madura, escala y que empieza a seducir a quien busca alternativas a CUDA sin hipotecar su stack.

¿Qué es AMD ROCm y por qué interesa?

ROCm (Radeon Open Compute) es una pila de software abierto que incluye controladores, herramientas, librerías y APIs para programar GPUs AMD desde bajo nivel (kernel) hasta aplicaciones de usuario. La idea es ofrecer una base unificada y de alto rendimiento para IA generativa y computación de alto rendimiento (HPC), con una migración relativamente sencilla desde ecosistemas existentes.

La plataforma soporta la ejecución de cargas intensivas en Linux y se centra en sacar todo el jugo a la GPU con un runtime, compiladores y librerías optimizadas. Se integran componentes como HIP para portar código CUDA, bibliotecas para comunicaciones colectivas tipo RCCL, aceleradores de álgebra lineal y herramientas de profiling y depuración.

Además del rendimiento, el valor de ROCm está en su naturaleza abierta: sin licencias cerradas y con amplio alineamiento con ecosistemas de IA y ciencia de datos como PyTorch, TensorFlow y ONNX. Esto lo convierte en una opción muy atractiva para universidades, PYMES y laboratorios que quieren escalar sin sobrecostes de software.

Qué trae ROCm 7: rendimiento, formatos ligeros y más compatibilidad

Con la versión 7, la plataforma pegó un salto importante. AMD reporta que es hasta 3,5× más rápida en inferencia y 3× en entrenamiento en ciertos escenarios, impulsado por el soporte de tipos de dato de baja precisión como FP4 y FP6 y mejoras en la pila de comunicación y ejecución distribuida.

Estos formatos reducidos permiten meter más datos en menos memoria y acelerar el throughput sin degradar la calidad de forma sensible en cargas adecuadas, lo que es clave para LLMs e IA generativa. La tendencia a bajar precisión (de FP32/FP16 a FP8/FP6/FP4) está alineada con lo que pide el estado del arte.

Otro punto crítico es la comunicación entre GPUs. Con la integración de RCCL (el equivalente de AMD a NCCL), ROCm 7 mejora la orquestación de tráfico GPU-GPU, reduciendo cuellos de botella al escalar a varios aceleradores. Esto facilita entrenamiento distribuido más estable y eficiente.

También hay un avance en compatibilidad: además de Linux, se trabaja en soporte para Windows (aún limitado, pero con progresos), y se amplía el abanico de hardware, incluyendo Instinct MI300X, Radeon recientes e incluso plataformas Ryzen AI. Para el desarrollador de escritorio, esto abre opciones fuera del data center.

Pila de software y componentes clave en ROCm

ROCm es más que un driver: es un stack completo. Incluye herramientas de desarrollo, compiladores, librerías numéricas, APIs de comunicación y utilidades de administración. A grandes rasgos, sus piezas más relevantes son:

• HIP: capa de portabilidad que permite adaptar kernels CUDA a GPUs AMD. HIPify automatiza buena parte del proceso de traducción.
• RCCL: librería de comunicaciones colectivas optimizada para GPUs AMD, muy útil en entrenamiento distribuido.
• MIOpen: primitivas para redes neuronales aceleradas por GPU.
• ROCm BLAS, FFT, Sparse y MAGMA: librerías de álgebra clave para rendimiento en IA/HPC.
• Herramientas como rocminfo, rocm-smi, perfiles, depuración y utilidades de orquestación (incluido soporte en Kubernetes vía GPU Operator).

Con este conjunto, se cubre el ciclo completo de desarrollo, desde escribir y portar kernels, hasta entrenar modelos y operar clústeres con visibilidad y control.

Diferencias respecto a CUDA: ¿qué cambia en la práctica?

Quien viene de NVIDIA y CUDA sabe que el rendimiento está ahí, pero también la dependencia de un proveedor. ROCm busca romper ese bloqueo con una propuesta abierta y económicamente más accesible. En la práctica:

• El stack es abierto y gratuito, ideal para clústeres IA con costes controlados.
• HIP facilita portar kernels CUDA, pero no todo es automático ni 1:1.
• La compatibilidad de hardware es más selectiva: no todas las Radeon de consumo están oficialmente soportadas.
• El soporte Windows avanza, y WSL2 ya asoma en ramas 6.x como beta, ampliando escenarios de desarrollo.

Si tu flujo depende de herramientas cerradas centradas en CUDA, puedes encontrar límites. Pero si usas PyTorch o TensorFlow y te mueves en open source, ROCm 7 empieza a ofrecer una experiencia de producción seria.

Compatibilidad de hardware y requisitos que debes tener en cuenta

Un matiz importante es la lista de GPUs oficialmente soportadas. NVIDIA habilita CUDA en gran parte de su catálogo, mientras que AMD restringe oficialmente ROCm a chips concretos (Instinct y ciertas Radeon). Eso no significa que otras GPUs no funcionen, pero sí que pueden requerir ajustes o no contar con soporte.

En generaciones previas hubo soporte para modelos como la Instinct MI25, que ofrecía ~12,5 TFLOPs FP32 y 768 GFLOPs FP64, pero a partir de ROCm 5.0 dejó de constar como soportada. Aun así, con algunos trucos puede funcionar para experimentar.

Por encima, la Instinct MI50 ronda ~13,3 TFLOPs FP32 y ~6,6 TFLOPs FP64, y modelos actuales como MI300X suben el listón con mucha memoria y músculo para LLMs. En consumo profesional, la Radeon Pro W7900 de 48 GB resulta interesante para LLMs que piden 35 GB o más por GPU.

Un requisito a menudo olvidado es el soporte de PCIe Atomics por parte de la CPU/placa. Si tu plataforma es anterior a ~2017, puedes encontrar bloqueos. Conviene validarlo antes de ir de compras o de intentar despliegues ambiciosos.

ROCm 6.1.3: multi‑GPU y WSL2 en el radar

Antes de ROCm 7, la rama 6.1.3 trajo cosas prácticas: compatibilidad con configuraciones multi‑GPU (clave para escalar servicios) y soporte beta para el Subsistema de Windows para Linux (WSL2). Esto permite ejecutar herramientas de IA pensadas para Linux desde un sistema Windows, una noticia muy útil para estaciones de trabajo mixtas.

Además, la compatibilidad añadió TensorFlow junto a PyTorch y ONNX, ampliando las opciones para quienes rotan entre frameworks. Si trabajas en Windows pero el despliegue real es Linux, WSL2 puede ser un puente cómodo para desarrollo.

Instalación base en Linux (Ubuntu) y verificación

Para un equipo personal con Ubuntu 20.04/22.04 LTS, la instalación oficial es directa. El flujo recomendado es añadir el repositorio de AMD, instalar el metapaquete de desarrollo y verificar la GPU:

Prepara el sistema con herramientas básicas y la clave del repo de AMD:

sudo apt update && sudo apt install -y wget gnupg2
wget https://repo.radeon.com/rocm/rocm.gpg.key
sudo gpg --dearmor -o /etc/apt/keyrings/rocm.gpg < rocm.gpg.key

Añade la lista de repositorios y actualiza el índice de paquetes:

echo 'deb [signed-by=/etc/apt/keyrings/rocm.gpg] https://repo.radeon.com/rocm/apt/debian/ ubuntu main' | sudo tee /etc/apt/sources.list.d/rocm.list
sudo apt update

Instala el stack de desarrollo y herramientas principales:

sudo apt install -y rocm-dev

Para validar la instalación, puedes consultar la GPU detectada y el estado del driver. Estas utilidades vienen en el stack de ROCm:

rocminfo
rocm-smi

Con esto deberías estar listo para compilar código en HIP o correr PyTorch con backend AMD. Si trabajas en Kubernetes, el GPU Operator facilita el aprovisionamiento de nodos con drivers y runtime listos.

¿Existe una conversión automática desde CUDA? Lo que realmente hay

Una duda recurrente es si se puede convertir un proyecto CUDA a ROCm sin tocar código. La respuesta corta: no hay un botón mágico 100% automático. Lo que sí existe es HIP y las herramientas hipify que ayudan a traducir gran parte de las APIs y kernels CUDA.

En proyectos reales, lo habitual es una migración semiautomática con revisiones manuales, sobre todo en zonas donde hay dependencias específicas de CUDA, extensiones no estándar o comportamientos sutiles. El esfuerzo varía según el tamaño del código y el uso de librerías de terceros.

A diferencia de otras iniciativas, la experiencia aquí está pensada para converger con el código en C++/HIP, lo que facilita mantener una base común. Aun así, es recomendable prototipar con módulos críticos antes de comprometer una migración completa.

Guía avanzada: hacer funcionar ROCm en una iGPU Vega (APU Ryzen)

En escenarios no soportados oficialmente, hay margen para trastear. Un caso interesante es el de un Ryzen 2200G con iGPU Vega 8, capaz de ~1,8 TFLOPs FP32 a 1,6 GHz. No es una bestia, pero da juego para experimentar con modelos pequeños.

El objetivo es que el sistema detecte la iGPU vía ROCm, instalar la versión más reciente posible y probar PyTorch. Para que PyTorch reconozca la GPU, en estos casos suele ser necesario compilar PyTorch desde fuente con parámetros específicos.

Primero, recuerda que la iGPU usa memoria compartida con la RAM. Asigna el máximo posible en BIOS (por ejemplo, 2 GB) para que haya margen de maniobra en inferencia.

Paso 1: instala ROCm y valida la GPU

Usa el procedimiento de Ubuntu anterior. Comprueba con rocminfo y openclinfo que el sistema ve la GPU:

sudo rocminfo
sudo openclinfo

Si se listan los agentes y la GPU aparece en el apartado correspondiente, tienes la base lista para el resto del proceso.

Paso 2: dependencias para compilar PyTorch con ROCm

Necesitarás herramientas de compilación y librerías adicionales que no entran con el instalador por defecto. Instala el toolchain y utilidades de build:

sudo apt install -y python3 python3-pip gcc g++ libatomic1 make \
cmake doxygen graphviz texlive-full

Y añade paquetes de ROCm y bibliotecas que PyTorch pedirá al compilar. Incluye drivers, MIOpen, RCCL y ecosistema HIP:

sudo apt install -y libstdc++-12-dev rock-dkms rocm-dev rocm-libs \
miopen-hip rccl rocthrust hipcub roctracer-dev cmake

Para MAGMA conviene usar Conda como proveedor de MKL. Instala Miniconda en tu carpeta de usuario y deja la ruta a mano:

mkdir -p ~/miniconda3
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda3/miniconda.sh
bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
rm -rf ~/miniconda3/miniconda.sh
~/miniconda3/bin/conda init bash

Reinicia la terminal para cargar el entorno. Esto te dará el MKLROOT necesario cuando enlaces MAGMA.

Paso 3: compila e instala MAGMA para ROCm

Antes de compilar, identifica el objetivo LLVM de tu GPU con rocminfo o la documentación de LLVM para AMDGPU. En una Vega 8 suele verse gfx902, pero el soporte práctico para estos experimentos se aproxima usando gfx900 (MI25) como objetivo.

Con esa referencia, ajusta PYTORCH_ROCM_ARCH y MKLROOT y ejecuta la construcción de MAGMA:

export PYTORCH_ROCM_ARCH=gfx900
# Clona el repo
git clone https://bitbucket.org/icl/magma.git
pushd magma
# Branch con corrección de memory leak
git checkout 5959b8783e45f1809812ed96ae762f38ee701972
cp make.inc-examples/make.inc.hip-gcc-mkl make.inc
# Añade linkers y objetivos de GPU al make.inc
echo 'LIBDIR += -L$(MKLROOT)/lib' >> make.inc
echo 'LIB += -Wl,--enable-new-dtags -Wl,--rpath,/opt/rocm/lib -Wl,--rpath,$(MKLROOT)/lib -Wl,--rpath,/opt/rocm/magma/lib' >> make.inc
echo 'DEVCCFLAGS += --gpu-max-threads-per-block=256' >> make.inc
export PATH="${PATH}:/opt/rocm/bin"
if [[ -n "$PYTORCH_ROCM_ARCH" ]]; then
  amdgpu_targets=`echo $PYTORCH_ROCM_ARCH | sed 's/;/ /g'`
else
  amdgpu_targets=`rocm_agent_enumerator | grep -v gfx000 | sort -u | xargs`
fi
for arch in $amdgpu_targets; do
  echo "DEVCCFLAGS += --amdgpu-target=$arch" >> make.inc
done
# Evita conflictos con OpenMP en hipcc
sed -i 's/^FOPENMP/#FOPENMP/g' make.inc
make -f make.gen.hipMAGMA -j $(nproc)
LANG=C.UTF-8 make lib/libmagma.so -j $(nproc) MKLROOT=~/miniconda3
make testing/testing_dgemm -j $(nproc) MKLROOT=~/miniconda3
popd
sudo mv magma /opt/rocm

Este paso te asegura disponer de álgebra lineal clave para PyTorch. Si falla, ajusta rutas o vuelve a validar el objetivo de GPU.

Paso 4: construye PyTorch con backend ROCm

Clona el repositorio y resuelve dependencias de Python. Incluye paquetes adicionales que suelen evitar errores de compilación:

git clone https://github.com/pytorch/pytorch.git
cd pytorch
git submodule update --init --recursive
sudo pip3 install -r requirements.txt
sudo pip3 install enum34 numpy pyyaml setuptools typing cffi future \
hypothesis typing_extensions CppHeaderParser argparse

Convierte el código CUDA a HIP con la herramienta incluida por AMD. Este paso adapta los kernels al backend AMD:

sudo python3 tools/amd_build/build_amd.py

Por último, compila usando el objetivo gfx900 y habilita ROCm. Ajusta MAX_JOBS según tus núcleos/hilos para no saturar la máquina:

sudo PYTORCH_ROCM_ARCH=gfx900 USE_ROCM=1 MAX_JOBS=4 python3 setup.py install

Ten paciencia: la compilación puede tardar horas y no tiene por qué ser en el equipo final si replicas dependencias en otra máquina.

Paso 5: estabilidad del driver y prueba con MNIST

Para mejorar la estabilidad en iGPU, conviene ajustar políticas de energía del driver AMDGPU. Consulta parámetros actuales y localiza ppfeaturemask:

find /sys/module/amdgpu/parameters/ -type f -name '*' -exec sh -c 'filename=${1%.*}; echo "File: ${filename##*/}"; cat "$1"' sh {} \;

Después, carga el módulo con un valor permisivo para ppfeaturemask. Este valor suele dar estabilidad en los casos descritos:

sudo modprobe amdgpu ppfeaturemask=0xfff73fff

Reinicia y clona los ejemplos de PyTorch. Instala dependencias del ejemplo de MNIST y usa un override para que PyTorch trate la iGPU como gfx 9.0.0 (MI25):

git clone https://github.com/pytorch/examples.git
cd examples/mnist
sudo pip3 install -r requirements.txt
sudo HSA_OVERRIDE_GFX_VERSION=9.0.0 python3 main.py --verbose

Si el backend de PyTorch marca la GPU disponible (aunque el nombre interno use «cuda»), es que está usando la ruta HIP. En PyTorch, «cuda» es la etiqueta histórica del backend GPU, independiente de si el proveedor es NVIDIA o AMD.

Windows, WSL2 y el camino a estaciones de trabajo mixtas

Aunque el soporte principal de ROCm sigue siendo Linux, el soporte en Windows está en camino. La rama 6.1.3 ya apunta a ejecución en WSL2 en beta, lo que permite desarrollar en Windows con herramientas de IA Linux.

Para quien trabaja en entornos corporativos o educativos con Windows, esto simplifica mucho la adopción: menos fricción para probar, preparar entornos y mover luego a producción sobre Linux nativo o Kubernetes.

Escalado: multi‑GPU, RCCL y orquestación

Si tu objetivo es entrenamiento distribuido, presta atención a RCCL y a la configuración multi‑GPU. ROCm 6.1.3 introdujo soporte multi‑GPU más fino, y ROCm 7 afina aún más la capa de comunicación para reducir latencias.

En despliegues sobre Kubernetes, el GPU Operator ayuda con drivers, runtime y nodos listos para workloads. Esto reduce el trabajo artesanal en clusters y aporta reproducibilidad para equipos y entornos CI/CD.

Coste, licencias y escenarios de uso

Uno de los puntos fuertes de ROCm es la ecuación coste‑beneficio. Al carecer de licencias cerradas, es factible montar clústeres IA más económicos con hardware AMD y software open source, algo muy atractivo para laboratorios, universidades y PYMES.

Eso no significa que ROCm valga para cualquier flujo. Si dependes de herramientas propietarias con soporte exclusivo en CUDA, encontrarás obstáculos. Pero si tu stack gira alrededor de PyTorch, TensorFlow, ONNX y ecosistema Python, el terreno es favorable.

Consejos prácticos para empezar y evitar tropiezos

Si vienes de cero en AMD, prueba primero con modelos pequeños. Valida que la GPU y drivers responden bien y que las librerías (MIOpen, RCCL, BLAS/FFT) están presentes.

Si ya usas PyTorch o TensorFlow, intenta portar módulos no críticos con HIP antes de mover todo. Detecta dependencias específicas de CUDA que requieran adaptación manual y mide rendimiento con y sin formatos reducidos (FP16/FP8/FP6/FP4).

Para clusters, planea la topología y la comunicación desde el inicio. RCCL y un buen tejido de interconexión marcan diferencia a escala. Considera GPU con mucha VRAM si vas a LLMs grandes.

La comunidad open source crece y lugares como r/StableDiffusion son una fuente constante de ideas y herramientas. Aprovecha hilos técnicos y repos con scripts para acelerar tu adopción o solucionar problemas raros.

Con todo lo anterior, la fotografía es clara: ROCm ha pasado de alternativa incipiente a plataforma con músculo, con una versión 7 que empuja fuerte en rendimiento (FP4/FP6), comunicación y soporte, una 6.1.3 que abrió puertas a multi‑GPU y WSL2, y una ruta de instalación razonablemente directa en Ubuntu. Hay límites en compatibilidad y algún trabajo manual al portar desde CUDA o en GPUs no oficiales, pero a cambio ofrece libertad, ahorro y una experiencia que ya huele a producción real.