Hyppää sisältöön

A new version of SD Connect and SD Desktop will be available from Monday, September 28. The major upgrade will introduce significant improvements, but also includes changes that are not compatible with the current version of the service. Click here to review the available support materials.

Warning!

Puhti and Mahti computing services have been decommissioned and no new jobs are accepted or executed on its compute nodes. Puhti and Mahti login nodes and storage services are planned to remain available until 15 October 2026. Clean up unnecessary files and move any data you need to keep by 31 August 2026. See the Roihu data migration guide for instructions on transferring your data to Roihu.

Monen GPU:n ja monen noodin koneoppiminen

Tässä oppaassa kerrotaan, miten voit hyödyntää useita GPU:ita ja useita noodeja koneoppimissovelluksissa CSC:n supertietokoneilla. Se on osa koneoppimisen opas.

Ensin selitämme yleiset periaatteet, kuten yhden noodin ja monen noodin työt sekä mekanismit useiden prosessien käynnistämiseen. Sen jälkeen käsittelemme joitakin yleisiä ohjelmistokehikoita ja sitä, miten niitä käytetään CSC:n supertietokoneilla: PyTorch DDP, PyTorch Lightning DDP:n kanssa, Accelerate, DeepSpeed ja TensorFlow'n tf.distribute.Strategy.

Useita GPU:ita ja useita noodeja

Jokaisessa erillisessä GPU-noodissa (eli yksittäisessä klusterin tietokoneessa) on kiinteä määrä GPU:ita. Roihu-GPU:ssa on 4 GPU:ta per noodi, ja LUMIssa on 8 GPU:ta per noodi. (Teknisesti LUMI-noodissa on 4 kaksisiruisen GPU:n korttia, mutta ohjelmiston näkökulmasta tämä näyttää samalta kuin 8 GPU:ta.) Koko supertietokoneessa voi olla kymmeniä tai jopa tuhansia GPU-noodeja. Katso lisätietoja oppaasta GPU-kiihdytetty koneoppiminen.

Jos tarvitset 1–4 GPU:ta (tai 1–8 LUMIssa), sinun tulee aina varata yhden noodin työ. Jos tarvitset enemmän kuin 4 GPU:ta (tai 8 LUMIssa), sinun täytyy varata monen noodin työ. Vaikka on teknisesti mahdollista varata esimerkiksi kaksi GPU:ta yhdestä noodista ja kaksi toisesta, tätä ei suositella muuten kuin testaustarkoituksiin, koska noodien välinen tiedonsiirto on aina hitaampaa kuin yhden noodin sisällä.

Varataksesi yhden noodin, jossa on N=1–4 GPU:ta Roihu-GPU:ssa tai 1–8 GPU:ta LUMIssa, tarvitset seuraavat valinnat (vaihda N todelliseen GPU-määrään):

#SBATCH --partition=gpumedium
#SBATCH --gres=gpu:gh200:N

#SBATCH --partition=small-g
#SBATCH --gpus-per-node=N

Huomaa: LUMIssa voit käyttää standard-g-osiota, jos pyydät koko noodia (8 GPU:ta).

Monen noodin töissä varaat aina kokonaisia noodeja, joten käytössäsi on 4:n GPU:n monikerta (tai 8:n LUMIssa). Esimerkiksi kahdella noodilla Roihussa käytössäsi on 2*4=8 GPU:ta.

#SBATCH --partition=gpularge
#SBATCH --gres=gpu:gh200:4
#SBATCH --nodes=2

Huomaa, että pääsy Roihun gpularge-osioon edellyttää skaalautuvuustestien lähettämistä.

#SBATCH --partition=standard-g
#SBATCH --gpus-per-node=8
#SBATCH --nodes=2

Huomaa, että --gres-valinta (tai LUMIssa --gpus-per-node) määrittää aina GPU:iden määrän per noodi, myös monen noodin tapauksessa. Jos siis varaamme 8 GPU:ta 2 noodin yli Roihussa, se tarkoittaa 4 GPU:ta jokaisessa noodissa, eli --gres=gpu:gh200:4.

Muiden kuin GPU-resurssien allokointi

Muut resurssit (CPU-ytimet ja CPU-muisti) tulee varata noodissa varattujen GPU:iden suhteessa. Jos esimerkiksi varaat 1 GPU:n 4:stä, muut resurssit tulee varata (enintään) 1/4:aan noodin kokonaisresursseista.

Roihussa jokainen GH200-GPU on itse asiassa superpiiri, joka sisältää GPU:n, CPU:n ja CPU-muistin yhdessä tiiviisti integroidussa yksikössä. Roihussa saat automaattisesti koko GH200-superpiirin muistin (95 GiB HBM3-muistia + 122 GiB LPDDR5-muistia = 217 GiB). CPU-ytimiä voit allokoida enintään 72 ydintä (superpiirin koko ARM-CPU:n).

LUMIssa käytä enintään 7 CPU-ydintä ja 60 Gt muistia per varattu GPU.

Huomaa, että GPU-muisti (tai VRAM) on kiinteä GPU-määrän mukaan; sitä ei voi allokoida enempää (tai vähempää).

Katso yhden GPU:n töiden ajon opas Slurm-esimerkeillä oikeista CPU- ja muistivarauksista.

GPU-käytön seuranta

Huomaa

Varmista, että koodisi osaa todella hyödyntää useita GPU:ita, sillä tämä vaatii tyypillisesti joitakin muutoksia ohjelmaan. Pelkkä useampien GPU:iden varaaminen ei riitä!

Voit seurata, että ohjelmasi käyttää kaikkia varattuja GPU:ita samoilla mekanismeilla, jotka on kuvattu GPU-kiihdytetyn koneoppimisen oppaassamme. Ainoa ero on se, että sinun pitäisi nyt nähdä tilastoja useammasta kuin yhdestä GPU:sta.

Esimerkkituloste nvidia-smi:llä 2 GPU:n työstä Roihussa (yksi noodi):

Mon Aug 17 16:01:05 2026       
+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 595.71.05              Driver Version: 595.71.05      CUDA Version: 13.2     |
+-----------------------------------------+------------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
|                                         |                        |               MIG M. |
|=========================================+========================+======================|
|   0  NVIDIA GH200 120GB             On  |   00000019:01:00.0 Off |                    0 |
| N/A   55C    P0            424W /  680W |    4911MiB /  97871MiB |     81%      Default |
|                                         |                        |             Disabled |
+-----------------------------------------+------------------------+----------------------+
|   1  NVIDIA GH200 120GB             On  |   00000029:01:00.0 Off |                    0 |
| N/A   56C    P0            426W /  680W |    4911MiB /  97871MiB |     86%      Default |
|                                         |                        |             Disabled |
+-----------------------------------------+------------------------+----------------------+

+-----------------------------------------------------------------------------------------+
| Processes:                                                                              |
|  GPU   GI   CI              PID   Type   Process name                        GPU Memory |
|        ID   ID                                                               Usage      |
|=========================================================================================|
|    0   N/A  N/A         1499602      C   .../wrappers/2.10-te/bin/python3       4902MiB |
|    1   N/A  N/A         1499603      C   .../wrappers/2.10-te/bin/python3       4902MiB |
+-----------------------------------------------------------------------------------------+

Tässä meillä on kaksi CPU-prosessia, joista kumpikin käyttää yhtä GPU:ta noin 80 %:n käyttöasteella (GPU-Util-sarake). Jos jommankumman GPU:n kohdalla näkyy sen sijaan 0 %, sitä ei käytetä lainkaan. Jos GPU:iden prosentit ovat melko matalia, se voi tarkoittaa, ettet tarvitse useita GPU:ita ainakaan laskentatehon vuoksi. Suurissa kielimalleissa niitä voidaan kuitenkin tarvita GPU-muistin vuoksi, joten tarkista myös GPU-muistin käyttö (Memory-Usage-sarake). Tässä esimerkissä muistinkäyttö on varsin pieni, noin 5 %.

Useiden prosessien käynnistäminen

Tyypillinen lähestymistapa monen GPU:n käsittelyyn syväoppimisessa on käynnistää yksi CPU-ohjausprosessi jokaista GPU:ta kohti. Näiden prosessien käynnistämisestä voi huolehtia joko syväoppimiskehikko itse (kuten PyTorchin torchrun) tai käyttämällä Slurmin MPI-toiminnallisuutta useiden MPI-tehtävien käynnistämiseen.

Saatavilla olevat kehikot

Monen GPU:n ja monen noodin koneoppimiseen on olemassa monia kehikoita, jotka ovat yleensä tiiviisti sidoksissa käyttämääsi syväoppimiskehikkoon. Tässä käsittelemme lähes yksinomaan PyTorchiin perustuvia ratkaisuja.

Riippumatta siitä, minkä kehikon valitset, kiinnitä huomiota töiden käynnistämistapaan. Joissakin tapauksissa, kuten PyTorch DDP:ssä, on erityinen käynnistin, joka käynnistää yksittäiset työt, kun taas toiset, kuten DeepSpeed, voivat käyttää tähän MPI:tä. Joissakin kehikoissa, kuten PyTorch Lightningissa, käynnistysmekanismi voi myös vaihdella sen mukaan, ajatko yhden noodin vai monen noodin työtä.

Kaikkien kehikoiden tulisi käyttää NCCL:ää Roihu-GPU:ssa (NVIDIA) tai RCCL:ää (AMD) LUMIssa nopeaan GPU:iden väliseen tiedonsiirtoon, vaikka yhteyksien muodostamiseen käytettäisiinkin MPI:tä.

PyTorch DDP

PyTorch distributed, ja erityisesti DistributedDataParallel (DDP), tarjoaa hyvän tavan ajaa monen GPU:n ja monen noodin PyTorch-töitä.

Siksi olemme tehneet DDP:n käytöstä CSC:n supertietokoneilla helpompaa luomalla esimerkkikokoelman yksinkertaisten DDP-töiden ajamisesta klusterissa. Esimerkeissä käytämme rendezvous -mekanismia noodien välisen viestinnän muodostamiseen, emme MPI:tä.

Esimerkki Slurm-eräajotyöstä PyTorch DDP:n ajamiseen yhdellä täydellä noodilla:

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=gpumedium
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=288
#SBATCH --time=1:00:00
#SBATCH --gres=gpu:gh200:4

module purge
module load python-pytorch

srun torchrun --standalone --nnodes=1 --nproc_per_node=4 myprog.py <options>

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=small-g
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=56
#SBATCH --gpus-per-node=8
#SBATCH --mem=480G
#SBATCH --time=1:00:00

module purge
module use /appl/local/laifs/modules
module load lumi-aif-singularity-bindings

export SIF=/appl/local/laifs/containers/lumi-multitorch-latest.sif

srun singularity run $SIF \
  torchrun --standalone --nnodes=1 --nproc_per_node=$SLURM_GPUS_PER_NODE myprog.py <options>

Esimerkki PyTorch DDP:n ajamisesta kahdella täydellä noodilla:

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=gpularge
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=288
#SBATCH --time=1:00:00
#SBATCH --gres=gpu:gh200:4

module purge
module load python-pytorch

export RDZV_HOST=$(hostname)
export RDZV_PORT=29400

srun torchrun \
    --nnodes=$SLURM_JOB_NUM_NODES \
    --nproc_per_node=4 \
    --rdzv_id=$SLURM_JOB_ID \
    --rdzv_backend=c10d \
    --rdzv_endpoint="$RDZV_HOST:$RDZV_PORT" \
    myprog.py <options>

Huomaa, että pääsy Roihun gpularge-osioon edellyttää skaalautuvuustestien lähettämistä.

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=small-g
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=56
#SBATCH --gpus-per-node=8
#SBATCH --mem=480G
#SBATCH --time=1:00:00

module purge
module use /appl/local/laifs/modules
module load lumi-aif-singularity-bindings

export SIF=/appl/local/laifs/containers/lumi-multitorch-latest.sif

export RDZV_HOST=$(hostname)
export RDZV_PORT=29400

srun singularity run $SIF torchrun \
    --nnodes=$SLURM_JOB_NUM_NODES \
    --nproc_per_node=$SLURM_GPUS_PER_NODE \
    --rdzv_id=$SLURM_JOB_ID \
    --rdzv_backend=c10d \
    --rdzv_endpoint="$RDZV_HOST:$RDZV_PORT" \
    myprog.py <options>

LUMI-esimerkeissä käytetään LUMI AI Factoryn PyTorch-asennusta.

Jos olet muuntamassa yhden GPU:n PyTorch-skriptiä, sinun täytyy tehdä muutama vaihe:

  1. Alusta init_process_group(), esimerkiksi:

    import torch.distributed as dist

dist.init_process_group(backend='nccl')

  2. Käytä oikeaa GPU:ta paikallisen rankin mukaan

    device_id = int(os.environ['LOCAL_RANK'])

    esimerkiksi siirtäessäsi myöhemmin dataa GPU:lle:

    x = x.to(device_id)

  3. Kääri mallisi DistributedDataParallel-luokalla:

    from torch.nn.parallel import DistributedDataParallel

model = DistributedDataParallel(model, device_ids=[device_id])

  4. Käytä DistributedSampler-luokkaa DataLoader-oliollasi:

    from torch.utils.data.distributed import DistributedSampler

train_sampler = DistributedSampler(train_dataset)
train_loader = DataLoader(dataset=train_dataset, sampler=train_sampler, ...)

Täysin toimiva esimerkki Roihulle löytyy pytorch-ddp-examples -repositoriostamme:

  • mnist_ddp.py näyttää Python-koodin yksinkertaisen CNN-mallin opettamiseen MNIST-datalla käyttäen PyTorch DDP:tä
  • run-ddp-gpu4.sh sisältää Slurm-skriptin opetuksen ajamiseen 4 GPU:lla yhdellä noodilla
  • run-ddp-gpu8.sh näyttää saman kahdelle täydelle noodille, yhteensä 8 GPU:lla

PyTorch Lightning DDP:n kanssa

PyTorch Lightning on suosittu korkeamman tason kehikko, joka on suunniteltu helpottamaan PyTorchin käyttöä. Monen GPU:n ja monen noodin töiden ajaminen Lightningilla on varsin helppoa. Jos haluat muuntaa olemassa olevan PyTorch-skriptisi Lightningille, ohjaamme sinut viralliseen PyTorch Lightning -dokumentaatioon.

Suosittelemme käyttämään DistributedDataParallelia (DDP) monen GPU:n ja monen noodin käyttöön. Sinun tarvitsee vain lisätä nämä valinnat Lightning Traineriin:

trainer = pl.Trainer(devices=args.gpus,
                     num_nodes=args.nodes,
                     accelerator='gpu',
                     strategy='ddp',
                     ...)

Sinun täytyy antaa sopivat arvot devices-parametrille (GPU:iden määrä per noodi) ja num_nodes-parametrille. Suosittelemme antamaan nämä komentoriviargumentteina:

def main():
    parser = argparse.ArgumentParser()

    parser.add_argument('--gpus', default=1, type=int,
                        help='number of GPUs per node')
    parser.add_argument('--nodes', default=1, type=int,
                        help='number of nodes')
    # any other command line arguments here
    args = parser.parse_args()

PyTorch Lightning -Slurm-skripti yhdelle noodille käyttäen kaikkia GPU:ita:

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=gpumedium
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=4
#SBATCH --cpus-per-task=72
#SBATCH --time=1:00:00
#SBATCH --gres=gpu:gh200:4

module purge
module load python-pytorch

srun python3 myprog.py --gpus=4 --nodes=1 <options>

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=small-g
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=8
#SBATCH --cpus-per-task=7
#SBATCH --gpus-per-node=8
#SBATCH --mem=480G
#SBATCH --time=1:00:00

module purge
module use /appl/local/laifs/modules
module load lumi-aif-singularity-bindings

export SIF=/appl/local/laifs/containers/lumi-multitorch-latest.sif

srun singularity run $SIF \
  python3 myprog.py --gpus=8 --nodes=1 <options>


PyTorch Lightning -Slurm-skripti kahdelle täydelle noodille käyttäen kaikkia GPU:ita:

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=gpularge
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=4
#SBATCH --cpus-per-task=72
#SBATCH --time=1:00:00
#SBATCH --gres=gpu:gh200:4

module purge
module load python-pytorch

srun python3 myprog.py --gpus=4 --nodes=2 <options>

Huomaa, että pääsy Roihun gpularge-osioon edellyttää skaalautuvuustestien lähettämistä.

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=small-g
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=8
#SBATCH --cpus-per-task=7
#SBATCH --gpus-per-node=8
#SBATCH --mem=480G
#SBATCH --time=1:00:00

module purge
module use /appl/local/laifs/modules
module load lumi-aif-singularity-bindings

export SIF=/appl/local/laifs/containers/lumi-multitorch-latest.sif

srun singularity run $SIF \
  python3 myprog.py --gpus=8 --nodes=2 <options>

Täysin toimivia esimerkkejä PyTorch Lightningin käytöstä yhdellä tai kahdella täydellä noodilla löytyy pytorch-ddp-examples -repositoriostamme.

Accelerate

Hugging Facen Accelerate on suosittu kehikko suurten kielimallien opettamiseen, ja se tekee edistyneempien opetusalgoritmien, kuten FSDP:n, käytöstä erittäin helppoa. Työn käynnistäminen Acceleratella on samanlaista kuin PyTorch DDP:llä, paitsi että meidän täytyy käyttää Accelerate-käynnistintä ja antaa lisäksi Accelerate-asetustiedosto.

Toimiva esimerkki LLM-hienosäädöstä löytyy tästä GitHub-repositoriosta (tarkista tiedostot, joiden nimi päättyy -accelerate.sh). Katso myös oppaamme LLM:ien käytöstä supertietokoneilla.

Esimerkki Acceleraten käytöstä kaikilla GPU:illa yhdellä noodilla:

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=gpumedium
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=288
#SBATCH --time=1:00:00
#SBATCH --gres=gpu:gh200:4

module purge
module load python-pytorch

srun accelerate launch \
 --config_file=accelerate_config.yaml \
 --num_processes=4 \
 --num_machines=1 \
 --machine_rank=0 \
 myprog.py <options>

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=small-g
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=56
#SBATCH --mem=480G
#SBATCH --time=1:00:00
#SBATCH --gpus-per-node=8

module purge
module use /appl/local/laifs/modules
module load lumi-aif-singularity-bindings

export SIF=/appl/local/laifs/containers/lumi-multitorch-latest.sif

srun singularity run $SIF accelerate launch \
 --config_file=accelerate_config.yaml \
 --num_processes=8 \
 --num_machines=1 \
 --machine_rank=0 \
 myprog.py <options>

Esimerkki Acceleraten ajamisesta kahdella täydellä noodilla (8 GPU:ta).

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=gpularge
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=288
#SBATCH --time=1:00:00
#SBATCH --gres=gpu:gh200:4

module purge
module load python-pytorch

NUM_PROCS=$(expr ${SLURM_NNODES} \* ${SLURM_GPUS_ON_NODE})
MAIN_PROCESS_IP=$(hostname -i)

RUN_CMD="accelerate launch \
                    --config_file=accelerate_config.yaml \
                    --num_processes=$NUM_PROCS \
                    --num_machines=$SLURM_NNODES \
                    --machine_rank=\$SLURM_NODEID \
                    --main_process_ip=$MAIN_PROCESS_IP \
                    myprog.py <options>"

srun bash -c "$RUN_CMD"

Huomaa, että pääsy Roihun gpularge-osioon edellyttää skaalautuvuustestien lähettämistä.

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=small-g
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=56
#SBATCH --gpus-per-node=8
#SBATCH --mem=480G
#SBATCH --time=1:00:00

module purge
module use /appl/local/laifs/modules
module load lumi-aif-singularity-bindings

export SIF=/appl/local/laifs/containers/lumi-multitorch-latest.sif

NUM_PROCESSES=$(expr $SLURM_NNODES \* $SLURM_GPUS_PER_NODE)
MAIN_PROCESS_IP=$(hostname -i)

RUN_CMD="accelerate launch \
                    --config_file=accelerate_config.yaml \
                    --num_processes=$NUM_PROCESSES \
                    --num_machines=$SLURM_NNODES \
                    --machine_rank=\$SLURM_NODEID \
                    --main_process_ip=$MAIN_PROCESS_IP \
                    myprog.py <options>"

srun singularity run $SIF bash -c "$RUN_CMD"

Huomaa hieman kömpelö tapa määritellä komento niin, että $SLURM_NODEID-muuttuja on escapettu, jotta se evaluoidaan vasta sillä varsinaisella noodilla, jossa sitä ajetaan. Normaalisti kaikki muuttujat evaluoidaan ensimmäisellä noodilla, mutta $SLURM_NODEID:n tulee olla eri jokaisessa noodissa, jotta hajautettu asetus toimii oikein.

Molemmat esimerkit käyttävät tätä accelerate_config.yaml-tiedostoa:

compute_environment: LOCAL_MACHINE
debug: false
distributed_type: MULTI_GPU
downcast_bf16: 'no'
gpu_ids: all
main_training_function: main
main_process_port: 29500
mixed_precision: bf16
num_processes: 1
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false

Jos haluat käyttää FSDP:tä, käytä yksinkertaisesti tämän kaltaista Accelerate-asetusta:

compute_environment: LOCAL_MACHINE
debug: false
distributed_type: FSDP
downcast_bf16: 'no'
fsdp_config:
  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
  fsdp_backward_prefetch_policy: BACKWARD_PRE
  fsdp_forward_prefetch: false
  fsdp_cpu_ram_efficient_loading: true
  fsdp_offload_params: false
  fsdp_sharding_strategy: FULL_SHARD
  fsdp_state_dict_type: SHARDED_STATE_DICT
  fsdp_sync_module_states: true
  fsdp_use_orig_params: true
gpu_ids: all
main_training_function: main
main_process_port: 29500
mixed_precision: bf16
num_processes: 1
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false

Täysin toimivia esimerkkejä Acceleraten käytöstä yhdellä tai kahdella täydellä noodilla löytyy pytorch-ddp-examples -repositoriostamme.

Lisää esimerkkejä LLM-hienosäädön tekemisestä Acceleratella löytyy llm-fine-tuning-examples -repositoriosta.

DeepSpeed

DeepSpeed on PyTorchin optimointiohjelmistopaketti, joka auttaa skaalaamaan sekä opetusta että päättelyä suurille syväoppimismalleille.

Esimerkki DeepSpeedin ajamisesta yhdellä täydellä noodilla käyttäen deepspeed-käynnistintä:

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=gpumedium
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=288
#SBATCH --time=1:00:00
#SBATCH --gres=gpu:gh200:4

module purge
module load python-pytorch

srun deepspeed myprog.py \
    --deepspeed --deepspeed_config my_ds_config.json \
    <further options>

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=small-g
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=56
#SBATCH --gpus-per-node=8
#SBATCH --mem=480G
#SBATCH --time=1:00:00

module purge
module use /appl/local/laifs/modules
module load lumi-aif-singularity-bindings

export SIF=/appl/local/laifs/containers/lumi-multitorch-latest.sif

srun singularity run $SIF \
  deepspeed myprog.py \
    --deepspeed --deepspeed_config my_ds_config.json \
    <further options>


Esimerkki DeepSpeedin ajamisesta kahdella täydellä noodilla käyttäen MPI:tä erillisen tehtävän käynnistämiseen jokaiselle GPU:lle:

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=gpularge
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=4
#SBATCH --cpus-per-task=72
#SBATCH --time=1:00:00
#SBATCH --gres=gpu:gh200:4

module purge
module load python-pytorch

srun python3 myprog.py \
    --deepspeed --deepspeed_config my_ds_config.json \
    <further options>

Huomaa, että pääsy Roihun gpularge-osioon edellyttää skaalautuvuustestien lähettämistä.

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=small-g
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=8
#SBATCH --cpus-per-task=7
#SBATCH --gpus-per-node=8
#SBATCH --mem=480G
#SBATCH --time=1:00:00

module purge
module use /appl/local/laifs/modules
module load lumi-aif-singularity-bindings

export SIF=/appl/local/laifs/containers/lumi-multitorch-latest.sif

srun singularity run $SIF python3 myprog.py \
    --deepspeed --deepspeed_config my_ds_config.json \
    <further options>

Jos olet muuntamassa yhden GPU:n PyTorch-skriptiä, sinun täytyy tehdä muutama vaihe:

  1. Varmista, että se käsittelee DeepSpeedin komentoriviargumentit, esimerkiksi:

    import argparse

parser = argparse.ArgumentParser()
# handle any own command line arguments here
parser = deepspeed.add_config_arguments(parser)

args = parser.parse_args()

  2. Alusta hajautettu ympäristö, esimerkiksi:

    import deepspeed

deepspeed.init_distributed()

  3. Alusta DeepSpeed-moottori:

    model = # defined in normal way
train_dataset = # defined normally

model_engine, optimizer, train_loader, __ = deepspeed.initialize(
    args=args, model=model, model_parameters=model.parameters(),
    training_data=train_dataset)

  4. Muokkaa opetusluuppia käyttämään DeepSpeed-moottoria:

    for batch in train_loader:
    data = batch[0].to(model_engine.local_rank)
    labels = batch[1].to(model_engine.local_rank)

    outputs = model_engine(data)
    loss = criterion(outputs, labels)

    model_engine.backward(loss)
    model_engine.step()

Katso DeepSpeedin Getting started -opas saadaksesi täydet tiedot. Erityisesti sinun täytyy myös luoda DeepSpeedin asetustiedosto.

Täysin toimiva esimerkki löytyy pytorch-ddp-examples -repositoriostamme:

  • mnist_deepspeed.py näyttää Python-koodin yksinkertaisen CNN-mallin opettamiseen MNIST-datalla käyttäen PyTorch DeepSpeediä
  • run-deepspeed-gpu4.sh sisältää Slurm-skriptin opetuksen ajamiseen 4 GPU:lla yhdellä noodilla
  • run-deepspeed-gpu8.sh näyttää saman kahdelle täydelle noodille, yhteensä 8 GPU:lla
  • ds_config.json näyttää tässä esimerkissä käytetyn DeepSpeed-asetustiedoston

TensorFlow'n tf.distribute.Strategy

TensorFlow'lla on myös omat sisäänrakennetut mekanisminsa hajautettuun opetukseen tf.distribute.Strategy-rajapinnassa.

Suomenkielinen tekoälykäännös

Sisällössä voi esiintyä virheellistä tietoa tekoälykäännöksestä johtuen.

Klikkaa tästä antaaksesi palautetta

Ymmärrän.