Ano ang AMD ROCm at paano ito i-install?

Kung gumagamit ka ng GPU acceleration para sa AI o HPC, malamang ay narinig mo na ang tungkol sa ROCm, ang open platform ng AMD na nagbibigay-daan sa iyong gamitin ang mga card nito para sa seryosong computing sa Linux at, parami nang parami, sa iba pang mga kapaligiran. Nilikha ang ROCm upang mahusay na maisama ang mga CPU at GPU at pangasiwaan ang mga totoong workload sa computing gamit ang isang open approach, na walang mga paghihigpit sa paglilisensya.

Sa mga nakaraang siklo, pinabilis ng AMD ang pag-unlad: Nagdala ang ROCm 7 ng malalakas na pagpapabuti sa pagganap at pagiging tugma, at ang mga nakaraang bersyon ng 6.x ay nagbukas ng pinto sa mga senaryo tulad ng WSL2 at mga configuration ng multi-GPU. Ang kawili-wili ay hindi na natin pinag-uusapan ang isang walang hanggang demo , kundi isang umuunlad at nagpapalawak na ecosystem na nagsisimula nang maging kaakit-akit sa mga naghahanap ng mga alternatibo sa CUDA nang hindi nakompromiso ang kanilang stack.

Ano ang AMD ROCm at bakit ito mahalaga?

Ang ROCm (Radeon Open Compute) ay isang open-source software stack na kinabibilangan ng mga driver, tool, library, at API para sa pagprograma ng mga AMD GPU mula sa antas ng kernel hanggang sa mga end-user application. Ang layunin ay magbigay ng isang pinag-isang, mataas na pagganap na pundasyon para sa generative AI at high-performance computing (HPC), na may medyo madaling paglipat mula sa mga umiiral na ecosystem.

Sinusuportahan ng platform ang pagpapatakbo ng masinsinang workload sa Linux at nakatuon sa pag-maximize ng performance ng GPU gamit ang na-optimize na runtime, mga compiler, at mga library. Isinasama nito ang mga component tulad ng HIP para sa pag-port ng CUDA code , mga library para sa kolektibong komunikasyon tulad ng RCCL, mga linear algebra accelerator, at mga profiling at debugging tool.

Bukod sa performance, ang halaga ng ROCm ay nakasalalay sa pagiging bukas nito: walang mga saradong lisensya at malawak na pagkakahanay sa mga ecosystem ng AI at data science tulad ng PyTorch, TensorFlow, at ONNX. Ginagawa nitong isang kaakit-akit na opsyon para sa mga unibersidad, SME, at mga laboratoryo na gustong mag-scale nang hindi nagkakaroon ng labis na gastos sa software.

Ano ang dulot ng ROCm 7: performance, lightweight form factor, at higit pang compatibility

Sa bersyon 7, ang platform ay gumawa ng isang makabuluhang hakbang pasulong. Iniulat ng AMD na ito ay umabot sa 3,5x na mas mabilis sa paghihinuha at 3x na mas mabilis sa pagsasanay sa ilang partikular na sitwasyon, dahil sa suporta para sa mga low-precision data type tulad ng FP4 at FP6 at mga pagpapabuti sa communication stack at distributed execution.

Ang mas maliliit na format na ito ay nagbibigay-daan para sa mas maraming data na maimpake sa mas kaunting memorya at mapabilis ang throughput nang hindi lubos na bumababa ang kalidad sa ilalim ng naaangkop na mga workload, na mahalaga para sa mga LLM at generative AI . Ang trend patungo sa mas mababang precision (mula FP32/FP16 hanggang FP8/FP6/FP4) ay naaayon sa kasalukuyang mga pinakamahusay na kasanayan.

Isa pang kritikal na punto ay ang komunikasyon ng GPU-to-GPU. Gamit ang integrasyon ng RCCL (katumbas ng AMD ng NCCL), pinapabuti ng ROCm 7 ang orkestasyon ng trapiko ng GPU-to-GPU , na binabawasan ang mga bottleneck kapag nag-i-scale sa maraming accelerator. Pinapadali nito ang mas matatag at mahusay na distributed training.

Mayroon ding pag-unlad sa compatibility: bukod sa Linux, ang suporta para sa Windows ay binubuo (limitado pa rin, ngunit umuunlad), at ang hanay ng hardware ay lumalawak upang maisama ang Instinct MI300X, mga kamakailang Radeon card, at maging ang mga Ryzen AI platform. Para sa mga desktop developer , nagbubukas ito ng mga opsyon na higit pa sa data center.

Software stack at mga pangunahing bahagi sa ROCm

Ang ROCm ay higit pa sa isang driver: isa itong kumpletong stack. Kabilang dito ang mga development tool, compiler, numeric library, communication API, at administration utilities . Sa pangkalahatan, ang mga pinakamahalagang bahagi nito ay:

• HIP: Isang portability layer na nagbibigay-daan sa mga kernel ng CUDA na iakma sa mga AMD GPU. I-automate ng HIPify ang karamihan sa proseso ng pagsasalin.
• RCCL: Kolektibong library ng komunikasyon na na-optimize para sa mga AMD GPU, lubhang kapaki-pakinabang sa ipinamahagi na pagsasanay.
• MIOpen: primitives para sa mga neural network Pinabilis ang GPU.
• ROCM BLAS, FFT, Sparse at MAGMA: Mga pangunahing aklatan ng algebra para sa pagganap ng AI/HPC.
• Mga tool gaya ng rocminfo, rocm-smi, profiling, debugging, at orchestration utilities (kabilang ang suporta para sa Kubernetes sa pamamagitan ng GPU Operator).

Saklaw ng set na ito ang buong siklo ng pag-unlad , mula sa pagsulat at pag-port ng mga kernel hanggang sa mga modelo ng pagsasanay at mga operating cluster na may visibility at kontrol.

Mga Pagkakaiba mula sa CUDA: Anong mga pagbabago sa pagsasanay?

Alam ng sinumang nagmumula sa NVIDIA at CUDA na naroon ang performance, ngunit gayundin ang vendor lock-in. Hangad ng ROCm na basagin ang hadlang na iyon gamit ang isang bukas at mas abot-kayang panukala. Sa pagsasagawa:

• Ang stack ay bukas at libre, perpekto para sa mga AI cluster na may kontroladong gastos.
• Pinapadali ng HIP ang pag-port ng mga kernel ng CUDA, ngunit Hindi lahat ay awtomatiko o 1:1.
• Mas pinipili ang compatibility ng hardware: Hindi lahat ng consumer Radeon ay opisyal na sinusuportahan.
• Sumusulong ang suporta sa Windows, at Ang WSL2 ay lumalabas na ngayon sa 6.x na mga sangay bilang isang beta, pagpapalawak ng mga senaryo ng pag-unlad.

Kung ang iyong daloy ng trabaho ay nakasalalay sa mga proprietary at CUDA-centric na tool, maaaring makaranas ka ng mga limitasyon. Ngunit kung gagamit ka ng PyTorch o TensorFlow at nagpapatakbo sa loob ng open source na kapaligiran , ang ROCm 7 ay magsisimulang mag-alok ng isang seryosong karanasan sa produksyon.

Compatibility ng hardware at mga kinakailangan na dapat mong isaalang-alang

Isang mahalagang pagkakaiba ang listahan ng mga opisyal na sinusuportahang GPU. Pinapagana ng NVIDIA ang CUDA sa halos lahat ng linya ng produkto nito , habang opisyal na nililimitahan ng AMD ang ROCm sa mga partikular na chip (Instinct at ilang Radeon card). Hindi ito nangangahulugan na hindi gagana ang ibang mga GPU, ngunit maaaring mangailangan ang mga ito ng mga pagsasaayos o tuluyang walang suporta.

Sinuportahan ng mga nakaraang henerasyon ang mga modelo tulad ng Instinct MI25, na nag-alok ng humigit-kumulang 12,5 TFLOP FP32 at 768 GFLOP FP64 , ngunit inalis ito sa listahan ng mga sinusuportahang processor simula sa ROCm 5.0. Gayunpaman, sa pamamagitan ng ilang mga workaround , maaari pa rin itong gumana para sa eksperimento.

Higit pa riyan, ang Instinct MI50 ay nag-aalok ng humigit-kumulang 13,3 TFLOPs FP32 at 6,6 TFLOPs FP64 , at ang mga kasalukuyang modelo tulad ng MI300X ay nagpapataas ng pamantayan na may sapat na memorya at lakas para sa mga LLM. Sa propesyonal na merkado ng mga mamimili, ang 48GB Radeon Pro W7900 ay isang kawili-wiling opsyon para sa mga LLM na nangangailangan ng 35GB o higit pa bawat GPU.

Isang madalas na hindi napapansing kinakailangan ay ang suporta sa CPU/motherboard para sa PCIe Atomics. Kung ang iyong platform ay mas luma kaysa sa 2017, maaaring makaranas ka ng mga isyu sa compatibility . Maipapayo na beripikahin ito bago bumili o sumubok ng mga ambisyosong deployment.

ROCm 6.1.3: Multi-GPU at WSL2 sa radar

Bago ang ROCm 7, ang sangay na 6.1.3 ay nagdala ng mga praktikal na pagpapabuti: suporta para sa mga configuration ng multi-GPU (susi para sa mga serbisyo sa pag-scale) at suporta sa beta para sa Windows Subsystem for Linux (WSL2). Pinapayagan nito ang pagpapatakbo ng mga tool ng AI na idinisenyo para sa Linux mula sa isang sistema ng Windows, isang napaka-kapaki-pakinabang na tampok para sa mga hybrid workstation.

Bukod pa rito, idinagdag ang compatibility sa TensorFlow kasama ang PyTorch at ONNX , na nagpapalawak ng mga opsyon para sa mga lumilipat sa pagitan ng mga framework. Kung gumagamit ka ng Windows ngunit ang aktwal na deployment ay sa Linux, ang WSL2 ay maaaring maging isang maginhawang tulay para sa pag-develop.

Base install sa Linux (Ubuntu) at pag-verify

Para sa isang personal na computer na nagpapatakbo ng Ubuntu 20.04/22.04 LTS, ang opisyal na pag-install ay diretso lamang. Ang inirerekomendang daloy ng trabaho ay idagdag ang AMD repository, i-install ang development metapackage, at i-verify ang GPU.

Ihanda ang sistema gamit ang mga pangunahing kagamitan at ang AMD repo key:

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

Idagdag ang listahan ng mga repositoryo at i-update ang index ng pakete:

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

I-install ang development stack at mga pangunahing tool:

sudo apt install -y rocm-dev

Para mapatunayan ang pag-install, maaari mong suriin ang natukoy na GPU at ang katayuan ng driver. Kasama ang mga utility na ito sa ROCm stack.

rocminfo
rocm-smi

Gamit ito, dapat ay handa ka nang mag-compile ng code sa HIP o magpatakbo ng PyTorch gamit ang isang AMD backend. Kung gumagamit ka ng Kubernetes, pinapasimple ng GPU Operator ang pag-provision ng mga node gamit ang mga ready-to-use na driver at runtime.

Mayroon bang awtomatikong conversion mula sa CUDA? Ano ba talaga ang meron?

Isang karaniwang tanong ay kung ang isang proyekto ng CUDA ay maaaring i-convert sa ROCm nang hindi hinahawakan ang code. Ang maikling sagot: walang 100% awtomatikong magic button . Ang umiiral ay ang HIP at ang mga tool ng hipafy na tumutulong sa pagsasalin ng malaking bahagi ng mga CUDA API at kernel.

Sa mga proyektong nasa totoong mundo, karaniwan ang isang semi-automated na migration na may manu-manong pagsusuri , lalo na sa mga lugar na may mga partikular na dependency sa CUDA, mga hindi karaniwang extension, o mga banayad na pag-uugali. Ang pagsisikap na kinakailangan ay nag-iiba depende sa laki ng code at ang paggamit ng mga third-party library.

Hindi tulad ng ibang mga inisyatibo, ang karanasan dito ay idinisenyo upang magtagpo sa C++/HIP code, na ginagawang mas madali ang pagpapanatili ng isang karaniwang pundasyon . Gayunpaman, ipinapayong gumawa ng prototype ng mga mahahalagang module bago mangako sa isang ganap na paglipat.

Advanced na Gabay: Pagpapatakbo ng ROCm sa isang Vega iGPU (Ryzen APU)

Sa mga sitwasyong hindi sinusuportahan, may puwang para sa eksperimento. Ang isang kawili-wiling halimbawa ay ang Ryzen 2200G na may iGPU Vega 8, na may kakayahang umabot sa ~1,8 TFLOPs FP32 sa 1,6 GHz . Hindi ito isang halimaw, ngunit pinapayagan nito ang eksperimento sa mas maliliit na modelo.

Ang layunin ay para matukoy ng sistema ang iGPU sa pamamagitan ng ROCm, mai-install ang pinakabagong bersyon na magagamit , at masubukan ang PyTorch. Sa mga kasong ito, para makilala ng PyTorch ang GPU, karaniwang kinakailangang i-compile ang PyTorch mula sa pinagmulan gamit ang mga partikular na parameter.

Una, tandaan na ang iGPU ay gumagamit ng shared memory kasama ng RAM. Ilaan ang pinakamataas na posibleng halaga sa BIOS (halimbawa, 2 GB) upang magkaroon ng kaunting espasyo sa paghihinuha.

Hakbang 1: I-install ang ROCm at i-validate ang GPU

Gamitin ang pamamaraang Ubuntu na inilarawan sa itaas. I-verify gamit ang rocminfo at openclinfo na kinikilala ng system ang GPU:

sudo rocminfo
sudo openclinfo

Kung nakalista ang mga ahente at lumalabas ang GPU sa katumbas na seksyon, handa na ang pundasyon para sa natitirang bahagi ng proseso.

Hakbang 2: Dependencies para sa pag-compile ng PyTorch sa ROCm

Kakailanganin mo ng karagdagang mga build tool at library na wala sa default na installer. I-install ang toolchain at mga build utility:

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

Nagdaragdag din ito ng mga pakete at library ng ROCm na hihilingin ng PyTorch habang nagko-compile. Kabilang dito ang mga driver, MIOpen, RCCL, at ang HIP ecosystem.

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

Para sa MAGMA, mainam na gamitin ang Conda bilang iyong MKL provider. I-install ang Miniconda sa iyong user folder at iwanan nang manu-mano ang path:

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

I-restart ang terminal para i-load ang environment. Ito ang magbibigay sa iyo ng kinakailangang MKLROOT kapag nag-bind ka ng MAGMA.

Hakbang 3: Bumuo at i-install ang MAGMA para sa ROCm

Bago i-compile, tukuyin ang target na LLVM ng iyong GPU gamit ang rocminfo o ang dokumentasyon ng AMDGPU LLVM. Sa isang Vega 8, karaniwan mong makikita ang gfx902, ngunit ang praktikal na suporta para sa mga eksperimentong ito ay humigit-kumulang gamit ang gfx900 (MI25) bilang target.

Gamit ang sangguniang iyon, ayusin ang PYTORCH_ROCM_ARCH at MKLROOT at patakbuhin ang MAGMA build:

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

Tinitiyak ng hakbang na ito na mayroon ka ng pangunahing linear algebra para sa PyTorch . Kung ito ay mabigo, ayusin ang mga ruta o muling i-validate ang target ng GPU.

Hakbang 4: Bumuo ng PyTorch gamit ang ROCm backend

I-clone ang repository at lutasin ang mga dependency sa Python . Magsama ng mga karagdagang pakete na kadalasang pumipigil sa mga error sa compilation:

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

I-convert ang CUDA code sa HIP gamit ang tool na ibinigay ng AMD. Iniaangkop ng hakbang na ito ang mga kernel sa backend ng AMD.

sudo python3 tools/amd_build/build_amd.py

Panghuli, i-compile gamit ang gfx900 target at paganahin ang ROCm. Ayusin ang MAX_JOBS ayon sa iyong mga core/thread upang maiwasan ang labis na pagkarga sa makina.

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

Maging matiyaga: ang compilation ay maaaring tumagal ng ilang oras at hindi kailangang nasa huling makina kung gagayahin mo ang mga dependency sa ibang makina.

Hakbang 5: Katatagan ng driver at pagsubok sa MNIST

Para mapabuti ang estabilidad ng iGPU, ayusin ang mga patakaran sa kuryente ng AMDGPU driver. Suriin ang kasalukuyang mga setting at hanapin ang ppfeaturemask:

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

Susunod, i-load ang module gamit ang isang permissive value para sa ppfeaturemask. Ang value na ito ay karaniwang nagbibigay ng stability sa mga kasong inilarawan:

sudo modprobe amdgpu ppfeaturemask=0xfff73fff

I-restart at i-clone ang mga sample ng PyTorch. I-install ang mga dependency mula sa sample ng MNIST at gumamit ng override para gawing gfx 9.0.0 (MI25) ang iGPU ng PyTorch:

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

Kung minarkahan ng PyTorch backend ang GPU bilang available (kahit na "cuda" ang internal na pangalan), ginagamit nito ang HIP route. Sa PyTorch, ang "cuda" ay ang historical label para sa GPU backend , NVIDIA man o AMD ang vendor.

Windows, WSL2, at ang landas sa pinaghalong workstation

Bagama't nananatiling Linux ang pangunahing suporta ng ROCm, paparating na ang suporta para sa Windows . Itinuturo na ng Bersyon 6.1.3 ang pagpapatupad ng WSL2 sa beta, na nagbibigay-daan sa pagbuo ng Windows gamit ang mga tool ng Linux AI.

Para sa mga nagtatrabaho sa mga korporasyon o pang-edukasyon na kapaligiran gamit ang Windows, lubos nitong pinapasimple ang pag-aampon : mas kaunting alitan sa pagsubok, paghahanda ng mga kapaligiran, at pagkatapos ay paglipat sa produksyon sa native na Linux o Kubernetes.

Pag-scale: Multi-GPU, RCCL, at Orchestration

Kung ang iyong layunin ay distributed training, bigyang-pansin ang mga setup ng RCCL at multi-GPU. Nagpakilala ang ROCm 6.1.3 ng mas mahusay na suporta sa multi-GPU , at higit pang pinagbuti ng ROCm 7 ang communication layer upang mabawasan ang latency.

Sa mga pag-deploy ng Kubernetes, ang GPU Operator ay tumutulong sa mga driver, runtime, at mga workload-ready node. Binabawasan nito ang manu-manong trabaho sa mga cluster at nagbibigay ng reproducibility para sa mga CI/CD team at environment.

Gastos, mga lisensya at mga sitwasyon sa paggamit

Isa sa mga kalakasan ng ROCm ay ang cost-benefit ratio nito. Dahil wala itong proprietary licenses , posible na bumuo ng mas abot-kayang AI clusters gamit ang AMD hardware at open-source software, na lubhang kaakit-akit sa mga laboratoryo, unibersidad, at SMEs.

Hindi ibig sabihin na angkop ang ROCm para sa lahat ng daloy ng trabaho. Kung aasa ka sa mga proprietary tool na may eksklusibong suporta sa CUDA , makakaranas ka ng mga balakid. Ngunit kung ang iyong stack ay umiikot sa PyTorch, TensorFlow, ONNX, at sa Python ecosystem, magiging paborable ang field na ito.

Mga praktikal na tip upang makapagsimula at maiwasan ang mga pitfalls

Kung bago ka pa lang sa AMD, subukan munang gumamit ng mas maliliit na modelo. Tiyakin na gumagana nang tama ang GPU at mga driver at mayroon ang mga kinakailangang library (MIOpen, RCCL, BLAS/FFT).

Kung gumagamit ka na ng PyTorch o TensorFlow, subukang i-port ang mga hindi kritikal na module gamit ang HIP bago ilipat ang lahat. Tukuyin ang mga partikular na dependency ng CUDA na nangangailangan ng manu-manong pag-aangkop at sukatin ang performance nang mayroon at walang pinababang mga format (FP16/FP8/FP6/FP4).

Para sa mga cluster, planuhin ang topology at komunikasyon mula sa simula. Malaki ang naitutulong ng RCCL at isang mahusay na interconnect fabric . Isaalang-alang ang mga GPU na may maraming VRAM kung gumagamit ka ng malalaking LLM.

Lumalago ang open source community, at ang mga lugar tulad ng r/StableDiffusion ay palaging pinagmumulan ng mga ideya at kagamitan. Samantalahin ang mga teknikal na thread at repository na may mga script upang mapabilis ang iyong paggamit o malutas ang mga hindi pangkaraniwang problema.

Sa lahat ng nabanggit, malinaw ang larawan: Ang ROCm ay mula sa isang bagong alternatibo patungo sa isang matatag na plataporma , kung saan ang bersyon 7 ay nagsusumikap sa pagganap (FP4/FP6), komunikasyon, at suporta; ang bersyon 6.1.3 ay nagbubukas ng pinto sa multi-GPU at WSL2; at isang medyo diretsong landas sa pag-install sa Ubuntu. May mga limitasyon sa compatibility at ilang manu-manong trabaho na kinakailangan kapag nagpo-port mula sa CUDA o sa mga hindi opisyal na GPU, ngunit bilang kapalit, nag-aalok ito ng kalayaan, pagtitipid sa gastos, at isang karanasan na parang produksyon sa totoong mundo na.