Ano ang AMD ROCm at paano ito i-install?

Kung nagtatrabaho ka sa GPU acceleration para sa AI o HPC, malamang na narinig mo na ang ROCm, ang bukas na platform ng AMD na hinahayaan kang gamitin ang mga card nito para sa seryosong pag-compute sa Linux at, lalong, sa iba pang mga kapaligiran pati na rin. Ipinanganak ang ROCm upang maisama nang mahusay ang CPU at GPU at lutasin ang mga tunay na pag-load ng computing na may bukas na diskarte, nang walang mga paghihigpit sa lisensya.

Sa nakalipas na ilang mga cycle, pinabilis ng AMD ang pag-unlad: Ang ROCm 7 ay nagdala ng makabuluhang pagpapabuti sa pagganap at pagiging tugma, at ang mga nakaraang 6.x na release ay nagbukas ng pinto sa mga sitwasyon tulad ng WSL2 at multi-GPU setup. Ang kawili-wiling bagay ay hindi na natin pinag-uusapan ang isang panghabang-buhay na demo., ngunit sa halip ay isang ecosystem na tumatanda, sumusukat at nagsisimulang umakit sa mga naghahanap ng mga alternatibo sa CUDA nang hindi sinasangla 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 mababang antas (kernel) hanggang sa mga application na tinukoy ng user. Ang ideya ay mag-alok ng pinag-isang, mataas na pagganap na base para Generative AI at high-performance computing (HPC), na may medyo madaling paglipat mula sa mga kasalukuyang ecosystem.

Sinusuportahan ng platform ang masinsinang pagsasagawa ng workload sa Linux at nakatuon sa pagsulit ng GPU na may na-optimize na runtime, compiler, at library. Ang mga bahagi tulad ng HIP ay isinama sa port ng CUDA code, mga aklatan para sa kolektibong komunikasyon gaya ng RCCL, linear algebra accelerators, at mga tool sa pag-profile at pag-debug.

Bilang karagdagan sa pagganap, ang halaga ng ROCm ay nakasalalay sa pagiging bukas nito: walang mga saradong lisensya at may malawak na pagkakahanay sa AI at data science ecosystem gaya ng PyTorch, TensorFlow, at ONNX. Ginagawa nitong isang napaka-kaakit-akit na opsyon para sa mga unibersidad, SME, at mga laboratoryo na naghahanap ng sukat nang walang karagdagang 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. Iniuulat ng AMD na hanggang 3,5x na mas mabilis sa hinuha at 3x na mas mabilis sa pagsasanay sa ilang partikular na sitwasyon. na hinihimok ng suporta para sa mga low-precision na uri ng data tulad ng FP4 at FP6 at mga pagpapabuti sa ipinamahagi na pagpapatupad at stack ng komunikasyon.

Ang mga pinababang format na ito ay nagbibigay-daan sa mas maraming data na mailagay sa mas kaunting memorya at mapabilis ang throughput nang hindi kapansin-pansing nagpapababa ng kalidad sa ilalim ng naaangkop na mga pagkarga, ano ang susi para sa mga LLM at generative AIAng trend patungo sa mas mababang katumpakan (mula sa FP32/FP16 hanggang FP8/FP6/FP4) ay naaayon sa estado ng sining.

Ang isa pang kritikal na punto ay ang komunikasyon sa pagitan ng mga GPU. Sa pagsasama ng RCCL (katumbas ng AMD ng NCCL), Pinapabuti ng ROCm 7 ang pagsasaayos ng trapiko ng GPU-GPU, binabawasan ang mga bottleneck kapag nag-scale sa maraming accelerators. Pinapadali nito ang mas matatag at mahusay na ipinamamahaging pagsasanay.

Mayroon ding isang hakbang pasulong sa pagiging tugma: bilang karagdagan sa Linux, Kami ay nagtatrabaho sa suporta para sa Windows (limitado pa rin, ngunit may pag-unlad), at ang saklaw ng hardware, kabilang ang Instinct MI300X, kamakailang Radeon at maging ang mga platform ng Ryzen AI. Para sa desktop developer, nagbubukas ito ng mga opsyon sa labas ng data center.

Software stack at mga pangunahing bahagi sa ROCm

Ang ROCm ay higit pa sa isang driver: ito ay isang kumpletong stack. May kasamang mga tool sa pag-develop, compiler, numerical na library, mga API ng komunikasyon at mga kagamitan sa pangangasiwaSa pangkalahatan, ang pinaka-kaugnay na mga piraso 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).

Sa set na ito, sakop ang kumpletong siklo ng pag-unlad, mula sa pagsusulat 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?

kanino nanggaling NVIDIA at alam ng CUDA na nandoon ang performance, ngunit ganoon din ang lock-in ng vendor. Sinisikap ng ROCm na basagin ang deadlock na iyon na may bukas at mas madaling ma-access na panukala sa ekonomiya. Sa pagsasanay:

• 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 umaasa ang iyong daloy ng trabaho sa mga saradong tool na nakasentro sa CUDA, maaari kang makatagpo ng mga limitasyon. Ngunit kung gumagamit ka ng PyTorch o TensorFlow at lumipat ka sa open source, ang ROCm 7 ay nagsisimulang maghatid ng seryosong karanasan sa produksyon.

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

Ang isang mahalagang nuance ay ang listahan ng mga opisyal na sinusuportahang GPU. Ang NVIDIA ay nagbibigay-daan sa CUDA sa halos lahat ng portfolio nito, habang opisyal na nililimitahan ng AMD ang ROCm sa mga partikular na chips (Instinct at ilang Radeon). Hindi iyon nangangahulugan na hindi gagana ang ibang mga GPU, ngunit maaaring mangailangan sila ng pagsasaayos o hindi suportado.

Sa mga nakaraang henerasyon mayroong suporta para sa mga modelo tulad ng Instinct MI25, na inaalok ~12,5 TFLOPS FP32 at 768 GFLOPs FP64, ngunit simula sa ROCm 5.0 ay hindi na ito nakalista bilang suportado. Kahit na, sa ilan Trick maaaring gumana para sa eksperimento.

Sa itaas, nag-hover ang Instinct MI50 ~13,3 TFLOPs FP32 at ~6,6 TFLOPs FP64, at ang mga kasalukuyang modelo tulad ng MI300X ay nagtataas ng bar na may maraming memorya at kalamnan para sa mga LLM. Para sa propesyonal na paggamit, ang 48GB Radeon Pro W7900 Ito ay kawili-wili para sa mga LLM na humihingi ng 35 GB o higit pa sa bawat GPU.

Ang isang madalas na hindi napapansin na kinakailangan ay ang suporta ng PCIe Atomics ng CPU/board. Kung ang iyong platform ay mas luma sa ~2017, maaari kang makatagpo ng mga pag-crash.Magandang ideya na patunayan ito bago mamili o subukan ang mga ambisyosong deployment.

ROCm 6.1.3: Multi-GPU at WSL2 sa radar

Bago ang ROCm 7, ang sangay ng 6.1.3 ay nagdala ng mga praktikal na bagay: suporta para sa mga multi-GPU na configuration (susi sa pag-scale ng mga serbisyo) at suporta sa beta para sa Windows Subsystem para sa Linux (WSL2). Nagbibigay-daan ito sa iyo na magpatakbo ng mga tool sa AI na nakabatay sa Linux mula sa isang Windows system, Napakakapaki-pakinabang na balita para sa mga pinaghalong workstation.

Bilang karagdagan, idinagdag ang pagiging tugma TensorFlow kasama ang PyTorch at ONNX, pagpapalawak ng mga opsyon para sa mga umiikot sa pagitan ng mga frameworks. Kung nagtatrabaho ka sa Windows ngunit ang iyong aktwal na deployment ay Linux, ang WSL2 ay maaaring maging isang maginhawang tulay para sa pag-unlad.

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. Ang inirerekomendang daloy ay idagdag ang AMD repository, i-install ang development metapackage, at i-verify ang GPU.:

Ihanda ang system gamit ang mga pangunahing kasangkapan 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 repositoryo at i-update ang package index:

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

Upang mapatunayan ang pag-install, maaari mong suriin ang nakitang katayuan ng GPU at driver. Ang mga utility na ito ay nasa ROCm stack:

rocminfo
rocm-smi

Sa pamamagitan nito dapat ay handa kang mag-compile ng code sa HIP o magpatakbo ng PyTorch gamit ang AMD backend. Kung nagtatrabaho ka sa Kubernetes, pinapadali ng GPU Operator pagbibigay ng mga node na may driver at handa na ang runtime.

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

Ang paulit-ulit na tanong ay kung posible bang i-convert ang isang proyekto ng CUDA sa ROCm nang hindi hinahawakan ang code. Ang maikling sagot: walang 100% awtomatikong magic buttonAng umiiral ay ang HIP at ang mga hipify na tool na tumutulong sa pagsasalin ng marami sa mga CUDA API at kernel.

Sa totoong mga proyekto, Ang karaniwang bagay ay isang semi-awtomatikong paglipat na may mga manu-manong pagsusuri, lalo na sa mga lugar kung saan may mga dependency na partikular sa CUDA, hindi karaniwang mga extension, o banayad na pag-uugali. Ang pagsisikap ay nag-iiba depende sa laki ng code at sa paggamit ng mga third-party na aklatan.

Hindi tulad ng iba pang mga inisyatiba, ang karanasan dito ay idinisenyo upang makipag-ugnay sa C++/HIP code, na ginagawang mas madaling mapanatili ang isang karaniwang base. Gayunpaman, ipinapayong gumawa ng prototype na may mga kritikal na module bago gumawa ng ganap na paglipat.

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

Sa mga hindi sinusuportahang sitwasyon, may puwang para sa pagkukunwari. Ang isang kawili-wiling kaso ay isang Ryzen 2200G na may Vega 8 iGPU, may kakayahang ~1,8 TFLOPs FP32 sa 1,6 GHzHindi ito hayop, ngunit nakakatuwang mag-eksperimento sa maliliit na modelo.

Ang layunin ay para sa system na matukoy ang iGPU sa pamamagitan ng ROCm, i-install ang pinakabagong bersyon na posible at subukan ang PyTorch. Upang makilala ng PyTorch ang GPU, sa mga kasong ito ay karaniwang kinakailangan i-compile ang PyTorch mula sa pinagmulan na may mga partikular na parameter.

Una, tandaan na ang iGPU ay gumagamit ng shared memory na may RAM. Maglaan hangga't maaari sa BIOS (halimbawa, 2 GB) upang magkaroon ng puwang para sa pagmamaniobra sa hinuha.

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

Gamitin ang pamamaraan ng Ubuntu sa itaas. Tingnan sa rocminfo at openclinfo na nakikita ng system ang GPU:

sudo rocminfo
sudo openclinfo

Kung nakalista ang mga ahente at lumabas ang GPU sa kaukulang seksyon, nakahanda na ang base para sa natitirang proseso.

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

Kakailanganin mo ng mga karagdagang tool sa pagbuo at mga aklatan na hindi kasama sa default na installer. I-install ang toolchain at mga utility mula sa build:

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

At nagdaragdag ng mga pakete at aklatan ng ROCm na hihilingin ng PyTorch kapag nag-compile. May kasamang mga driver, MIOpen, RCCL at 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 ipinapayong gamitin ang Conda bilang MKL provider. I-install ang Miniconda sa iyong folder ng user at iwanan ang ruta sa kamay:

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 pandulo upang i-load ang kapaligiran. Bibigyan ka nito ng kinakailangang MKLROOT kapag na-link mo ang MAGMA.

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

Bago mag-compile, tukuyin ang LLVM target ng iyong GPU gamit ang rocminfo o ang dokumentasyon ng LLVM para sa AMDGPU. Sa isang Vega 8 karaniwan mong nakikita ang gfx902, ngunit praktikal na suporta Para sa mga eksperimentong ito tinatantya namin ang paggamit ng gfx900 (MI25) bilang target.

Gamit ang sanggunian na iyon, inaayos ang PYTORCH_ROCM_ARCH at MKLROOT at nagpapatakbo ng 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 Key linear algebra para sa PyTorchKung nabigo ito, ayusin ang mga ruta o muling patunayan ang target ng GPU.

Hakbang 4: Bumuo ng PyTorch gamit ang ROCm backend

Kino-clone ang repository at niresolba ang mga dependency Sawa. May kasamang mga karagdagang pakete na karaniwang umiiwas 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 kasama ng AMD. Ang hakbang na ito ay umaangkop sa mga kernel sa AMD backend:

sudo python3 tools/amd_build/build_amd.py

Panghuli, mag-compile gamit ang gfx900 target at paganahin ang ROCm. Ayusin ang MAX_JOBS ayon sa iyong mga core/thread para maiwasan ang sobrang karga ng makina:

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

Maging matiyaga: maaaring tumagal ng ilang oras ang compilation at hindi ito kailangang nasa panghuling computer kung gagayahin mo ang mga dependency sa isa pang makina.

Hakbang 5: Katatagan ng driver at pagsubok sa MNIST

Upang mapabuti ang katatagan sa iGPU, ipinapayong ayusin ang mga patakaran sa kapangyarihan ng driver ng AMDGPU. Suriin ang kasalukuyang mga parameter at hanapin ang ppfeaturemask:

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

Pagkatapos, i-load ang module na may permissive value para sa ppfeaturemask. Ang halagang ito ay karaniwang nagbibigay ng katatagan sa mga kasong inilarawan:

sudo modprobe amdgpu ppfeaturemask=0xfff73fff

I-restart at i-clone ang mga halimbawa ng PyTorch. Mag-install ng mga dependency ng halimbawa ng MNIST at gumamit ng override para gawin ng PyTorch na ituring ang iGPU bilang 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

Kung minarkahan ng backend ng PyTorch ang GPU bilang available (kahit na ang panloob na pangalan ay gumagamit ng "cuda"), ginagamit nito ang ruta ng HIP. Sa PyTorch, ang "cuda" ay ang makasaysayang label para sa backend ng GPU., hindi alintana kung ang provider ay NVIDIA o AMD.

Windows, WSL2, at ang landas sa pinaghalong workstation

Bagama't nananatiling Linux ang pangunahing suporta ng ROCm, Paparating na ang suporta sa WindowsAng 6.1.3 na sangay ay nagta-target na ngayon ng WSL2 beta, na nagpapagana ng pag-develop sa Windows gamit ang mga tool sa Linux AI.

Para sa mga nagtatrabaho sa corporate o educational environment na may Windows, Ito ay lubos na nagpapadali sa pag-aampon: Mas kaunting alitan para sa pagsubok, paghahanda ng mga kapaligiran, at pagkatapos ay lumipat sa produksyon sa katutubong Linux o Kubernetes.

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

Kung ang iyong layunin ay distributed training, bigyang pansin ang RCCL at multi-GPU configuration. Ipinakilala ng ROCm 6.1.3 ang mas pinong suporta sa multi-GPU, at higit pang pinipino ng ROCm 7 ang layer ng komunikasyon upang mabawasan ang mga latency.

Sa mga deployment ng Kubernetes, tumutulong ang GPU Operator sa mga driver, runtime, at workload-ready node. Binabawasan nito ang gawaing kamay 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 lakas ng ROCm ay ang cost-benefit equation. Kulang sa mga saradong lisensya, posible na mag-set up ng mas matipid na AI cluster na may AMD hardware at open source software, isang bagay na talagang kaakit-akit para sa mga laboratoryo, unibersidad at SME.

Hindi iyon nangangahulugan na ang ROCm ay wasto para sa anumang daloy. Kung umaasa ka sa pagmamay-ari na mga tool na may eksklusibong suporta sa CUDAMakakaharap ka ng mga hadlang. Ngunit kung ang iyong stack ay umiikot sa PyTorch, TensorFlow, ONNX, at sa Python ecosystem, ang terrain ay paborable.

Mga praktikal na tip upang makapagsimula at maiwasan ang mga pitfalls

Kung bago ka sa AMD, subukan muna ang mas maliliit na modelo. Pinapatunayan na mahusay na tumugon ang GPU at mga driver at na ang mga aklatan (MIOpen, RCCL, BLAS/FFT) ay naroroon.

Kung gumagamit ka na ng PyTorch o TensorFlow, subukang mag-port ng mga hindi kritikal na module gamit ang HIP bago ilipat ang lahat. Nakikita ang mga dependency na partikular sa CUDA na nangangailangan ng manu-manong pag-aangkop at pagsukat ng pagganap nang may at walang pinababang mga format (FP16/FP8/FP6/FP4).

Para sa mga cluster, planuhin ang topology at komunikasyon mula sa simula. RCCL at isang magandang interconnection fabric gumawa ng pagkakaiba sa sukat. Isaalang-alang ang mga GPU na may maraming VRAM kung nagtatrabaho ka sa malalaking LLM.

Ang open source na komunidad ay lumalaki, at ang mga lugar tulad ng r/StableDiffusion ay isang palaging pinagmumulan ng mga ideya at tool. Samantalahin ang mga teknikal na thread at repo na may mga script para mapabilis ang iyong pag-aampon o ayusin ang mga bihirang isyu.

Sa lahat ng nasa itaas, malinaw ang larawan: Ang ROCm ay lumipat mula sa isang bagong alternatibo patungo sa isang malakas na platform, na may bersyon 7 na nagtutulak nang husto sa pagganap (FP4/FP6), komunikasyon, at suporta, isang 6.1.3 na nagbukas ng pinto sa multi-GPU at WSL2, at isang makatuwirang tuwirang landas sa pag-install sa Ubuntu. May mga limitasyon sa compatibility at ilang manu-manong trabaho kapag nag-port mula sa CUDA o sa hindi opisyal na mga GPU, ngunit bilang kapalit ay nag-aalok ito ng kalayaan, pagtitipid, at karanasan na katulad ng tunay na produksyon.