nnScaler est un moteur de parallélisation qui compile un modèle de réseau neuronal profond (DNN) conçu pour l'exécution sur un seul GPU dans un programme capable de s'exécuter en parallèle sur plusieurs GPU.
Facilité d'utilisation : seules quelques lignes de code doivent être modifiées pour permettre la parallélisation automatisée.
Pythonique : la sortie de parallélisation est en code PyTorch, ce qui la rend facile à comprendre pour les utilisateurs et pratique pour un développement ou une personnalisation ultérieurs.
Extensibilité : nnScaler expose une API pour prendre en charge de nouveaux opérateurs pour les modèles émergents.
Fiabilité : Vérifié par diverses sessions de formation de bout en bout, nnScaler est un système fiable.
Performances : en explorant un vaste espace de parallélisation, nnScaler peut améliorer considérablement les performances de formation parallèle.
Pour les scientifiques de DNN , ils peuvent se concentrer sur la conception de modèles avec PyTorch sur un seul GPU, tout en laissant les complexités de parallélisation à nnScaler. Il introduit des techniques de parallélisme innovantes qui surpassent les méthodes existantes en termes de performances. De plus, nnScaler prend en charge l'extension des modules DNN avec de nouvelles structures ou modèles d'exécution, permettant aux utilisateurs de paralléliser leurs modèles DNN personnalisés.
Les experts en systèmes DNN peuvent exploiter nnScaler pour explorer de nouveaux mécanismes et politiques de parallélisation DNN pour les modèles émergents. En fournissant des fonctions définies par l'utilisateur pour les nouveaux opérateurs non reconnus par nnScaler, il garantit une parallélisation transparente des nouveaux modèles DNN. Par exemple, pour faciliter la prise en charge de séquences longues dans les LLM.
Installez les packages suivants avant l'installation de nnScaler :
Python >= 3.8, < 3.11 (3.10 is recommanded) PyTorch >= 2.0, < 2.4 (2.2.0 is recommanded)
Exécutez les commandes ci-dessous dans le répertoire nnScaler :
pip install -r requirements.txt pip install -e .
En outre, pour éviter l'erreur cppimport , il doit également inclure le répertoire nnScaler dans la variable d'environnement PYTHONPATH :
export NNSCALER_HOME=$(pwd)
export PYTHONPATH=${NNSCALER_HOME}:$PYTHONPATHInstallez les packages requis pour exécuter Llama-3. En outre, une certaine version de la bibliothèque CUDA est nécessaire lors de l'installation flash-attn. Par exemple, CUDA V11.8 est nécessaire si vous utilisez PyTorch 2.20.
python -m pip install transformers==4.40.0 flash-attn==2.5.5 tensorboard
Obtenez l'accès au modèle Llama-3 depuis HuggingFace, où vous recevrez un jeton d'accès qui doit être défini comme variable d'environnement :
export HF_TOKEN=<HUGGINGFACE_ACCESS_TOKEN>
Vous pouvez trouver tous les exemples de code sur examples/llama3_8B_128K . Comme indiqué ci-dessous, un utilisateur doit :
Enveloppez le modèle : incluez le calcul des pertes et d’autres composants nécessaires.
Configurer les composants : configurez le modèle, l'optimiseur et le chargeur de données.
Initialiser et démarrer : dans la fonction principale, créez un entraîneur nnScaler avec les configurations ci-dessus et démarrez le processus de formation.
# importez l'entraîneur intégré compatible avec la parallélisation nnScaler à partir de nnscaler.cli.trainer import Trainer# wrap model pour inclure le calcul des pertes, etc.class WrapperModel(torch.nn.Module):def __init__(self, model_id):super(). __init__()self.model = AutoModelForCausalLM.from_pretrained(model_id, attn_implementation='flash_attention_2')def forward(self, samples):outputs = self.model.model(input_ids=samples['net_input']['src_tokens'],use_cache=False,return_dict=False,
)loss = torch.sum(chunk_linear_cross_entropy(outputs[0], self.model.lm_head.weight, samples['target'], ...))retour de perte, samples['ntokens'], samples['nsentences'] def main(args):# data configdataloader_config = ... # modèle configmodel_config = ModelConfig(type=WrapperModel,args={'model_id' : args.model_id,
},
)# hyperparamètres de l'optimiseur optimiseur_config = OptimizerConfig(type=MixedPrecisionAdamW,args={'lr' : 2e-5, 'betas' : (0.9, 0.95), 'weight_decay' : 0.0, 'fused' : True},#... )#...# entraîneur de configuration avec les configurations du chargeur de données/modèle/optimiseur, etc. entraîneur = Trainer(train_args=TrainerArgs(#...model=model_config,optimizer=optimizer_config,dataloader=dataloader_config,#...))trainer.run()Ensuite, nous pouvons démarrer l'exemple, et toutes les tâches de parallélisation seront terminées automatiquement par nnScaler.
cd examples/llama3_8B_128K# préparer les données d'entraînement :python bookcorpus.py --data_path_or_name bookcorpus/bookcorpus --tokenizer_path_or_name meta-llama/Meta-Llama-3-8B-Instruct --save_path ./bookcorpus_llama3_4K --sequence_length 4096# construire le mini modèlepython create_mini_model.py --model_id meta-llama/Meta-Llama-3-8B-Instruct --output_id ./llama3_mini#compile et exécutez en utilisant le parallélisme des données + zero1torchrun --nproc_per_node=2 train.py --plan_ngpus 1 --runtime_ngpus 2 --name llama3_debug --model_id ./llama3_mini --dataset_path ./bookcorpus_llama3_4K
Nous fournissons également un exemple pour montrer comment paralléliser un modèle via une interface compatible PyTorch Lightning dans nnScaler.
Recherchez l'exemple nanoGPT dans le dépôt nnScaler :
exemples de cd/nanogpt
Installez les dépendances de nanoGPT :
pip install -r exigences.txt
Préparez l'ensemble de données :
python nanoGPT/data/shakespeare_char/prepare.py
Test avec un seul GPU
Vous pouvez maintenant exécuter train_nnscaler.py avec torchrun <https://pytorch.org/docs/stable/elastic/run.html> :
torchrun --nproc_per_node=1 train_nnscaler.py nanoGPT/config/train_shakespeare_char.py
Cela entraînera un bébé modèle GPT sur un seul GPU. Cela prendra plusieurs minutes et la meilleure perte de validation sera d'environ 1,47.
Test avec multi-GPU
Par défaut, nnScaler parallélise un modèle sur des GPU avec le parallélisme des données . Si vous disposez de 4 GPU sur un nœud :
torchrun --nproc_per_node=4 train_nnscaler.py nanoGPT/config/train_shakespeare_char.py
Ou si vous avez plusieurs nœuds, par exemple 2 nœuds avec 4 GPU chacun :
# on each node torchrun --nnodes=2 --nproc_per_node=4 --rdzv-id=NNSCALER_NANOGPT --rdzv-backend=c10d --rdzv-endpoint=<IP> train_nnscaler.py nanoGPT/config/train_shakespeare_char.py
REMARQUE : La taille du lot local est fixe par défaut, donc l'utilisation de plus de travailleurs entraînera une taille de lot globale plus grande.
? Pour les utilisations avancées, veuillez rester à l’écoute de notre future version.
nnScaler a été adopté par plusieurs projets, y compris des explorations de produits et de recherche :
(YOCO)Vous ne mettez en cache qu'une seule fois : architectures décodeur-décodeur pour les modèles de langage
LongRoPE : extension de la fenêtre contextuelle LLM au-delà de 2 millions de jetons
Post-formation pour la version contextuelle longue de la série Phi-3
Vous pouvez trouver l'évaluation des artefacts pour OSDI'24 avec les conseils ici. Veuillez citer nnScaler dans vos publications si cela aide votre recherche :
@inproceedings{lin2024nnscaler,
title = {nnScaler: Constraint-Guided Parallelization Plan Generation for Deep Learning Training},
author={Lin, Zhiqi and Miao, Youshan and Zhang, Quanlu and Yang, Fan and Zhu, Yi and Li, Cheng and Maleki, Saeed and Cao, Xu and Shang, Ning and Yang, Yilei and Xu, Weijiang and Yang, Mao and Zhang, Lintao and Zhou, Lidong},
booktitle={18th USENIX Symposium on Operating Systems Design and Implementation (OSDI 24)},
pages={347--363},
year={2024}
}Ce projet accueille les contributions et suggestions. La plupart des contributions nécessitent que vous acceptiez un contrat de licence de contributeur (CLA) déclarant que vous avez le droit de nous accorder, et que vous nous accordez effectivement, le droit d'utiliser votre contribution. Pour plus de détails, visitez https://cla.opensource.microsoft.com.
Lorsque vous soumettez une pull request, un robot CLA déterminera automatiquement si vous devez fournir un CLA et décorera le PR de manière appropriée (par exemple, vérification du statut, commentaire). Suivez simplement les instructions fournies par le bot. Vous n’aurez besoin de le faire qu’une seule fois pour tous les dépôts utilisant notre CLA.
Ce projet a adopté le code de conduite Microsoft Open Source. Pour plus d’informations, consultez la FAQ sur le code de conduite ou contactez [email protected] pour toute question ou commentaire supplémentaire.
Ce projet peut contenir des marques ou des logos pour des projets, des produits ou des services. L'utilisation autorisée des marques ou logos Microsoft est soumise et doit respecter les directives relatives aux marques et aux marques de Microsoft. L'utilisation des marques ou logos Microsoft dans les versions modifiées de ce projet ne doit pas prêter à confusion ni impliquer le parrainage de Microsoft. Toute utilisation de marques ou de logos tiers est soumise aux politiques de ces tiers.
Vous pouvez trouver notre dépôt public sur https://github.com/microsoft/nnscaler ou le dépôt interne de Microsoft https://aka.ms/ms-nnscaler. Pour toute question ou demande de renseignements, veuillez nous contacter à [email protected].
