Comment faire fonctionner la formation distribuée de Pytorch sur CentOS

La formation distribuée par Pytorch sur le système CentOS nécessite la suite des étapes suivantes:

1. Installation de Pytorch: la prémisse est que Python et PIP sont installés dans le système CentOS. Selon votre version CUDA, obtenez la commande d'installation appropriée sur le site officiel de Pytorch. Pour la formation CPU uniquement, vous pouvez utiliser la commande suivante:

    pip installer torch TorchVision Torchaudio

   Si vous avez besoin d'une prise en charge GPU, assurez-vous que la version correspondante de CUDA et CUDNN est installée et utilisez la version Pytorch correspondante à installer.

2. Configuration de l'environnement distribué: la formation distribuée nécessite généralement plusieurs machines ou des GPU multiples uniques. Tous les nœuds participant à la formation doivent être en mesure de réseauter les uns aux autres et de configurer correctement les variables d'environnement telles que MASTER_ADDR (Adresse IP de nœud maître) et MASTER_PORT (tout numéro de port disponible).

3. Écriture de script de formation distribuée: Utilisez le package torch.distributed de Pytorch pour écrire des scripts de formation distribués. torch.nn.parallel.DistributedDataParallel est utilisé pour envelopper votre modèle, tandis que torch.distributed.launch ou accelerate Libraries sont utilisés pour commencer la formation distribuée.

   Voici un exemple d'un script de formation distribué simplifié:

    Importer une torche
   importer torch.nn comme nn
   Importer Torch.optim comme Optim
   De Torch.nn.Parallel Import DistributedDataparallel en tant que DDP
   Importer Torch.Distributed comme dist
   
   Def Train (Rank, World_Size):
       dist.init_process_group (backend = 'nccl', init_method = 'env: //') # initialisez le groupe de processus, utilisez le modèle backend NCCL = ... # votre modèle de définition modèle.cuda (rang) # Déplacez le modèle vers le GPU spécifié
   
       DDP_MODEL = DDP (modèle, Device_IDS = [RAND]) # Utilisez DDP pour envelopper les critères du modèle = nn.crossentropyloss (). CUDA (RANK) # Fonction de perte Optimizer = Optim.Adam (DDP_MODEL.Parameters (), LR = 0.001) # Optimizer DataSet = ... # Your Dataset Sampler Sampler = torch.utils.data.distributed.distributedSampler (ensemble de données, num_replicas = world_size, rang = rang)
       lourdeur = torch.utils.data.dataloader (ensemble de données, batch_size = ..., échantillonneur = échantillonneur)
   
       pour l'époque dans la gamme (...):
           sampler.set_epoch (époque) # Pour chaque rééchantillonnage de l'époque, cible dans le chargeur:
               Data, Target = Data.cuda (Rank), Target.cuda (Rank)
               optimizer.zero_grad ()
               output = ddp_model (données)
               Perte = critères (sortie, cible)
               perte.backward ()
               Optimizer.Step ()
   
       dist.destroy_process_group () # Détruiser le groupe de processus si __name__ == "__main__":
       Importer Argparse
       parser = argparse.argumentParser ()
       parser.add_argument ('- World-Size', type = int, default = 2)
       parser.add_argument ('- rank', type = int, default = 0)
       args = parser.parse_args ()
       Train (Args.Rank, args.world_size)

4. Startup de formation distribuée: Utilisez l'outil torch.distributed.launch pour commencer la formation distribuée. Par exemple, exécutez deux GPU:

    python -m torch.distributed.launch --nproc_per_node = 2 your_training_script.py

   Dans le cas de plusieurs nœuds, assurez-vous que chaque nœud exécute le processus correspondant et que les nœuds peuvent accéder les uns aux autres.

5. Surveillance et débogage: une formation distribuée peut rencontrer des problèmes de communication ou de synchronisation du réseau. Utilisez nccl-tests pour tester si la communication entre les GPU est normale. L'enregistrement détaillé est essentiel pour le débogage.

Veuillez noter que les étapes ci-dessus fournissent un cadre de base qui peut devoir être ajusté en fonction des besoins et de l'environnement spécifiques dans les applications réelles. Il est recommandé de se référer aux instructions détaillées de la documentation officielle de Pytorch sur la formation distribuée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!