Meta LLaMa et alpagas en liberté dans le labo ! Exécution locale de grands modèles de langage

Ces derniers mois, de grands modèles de langage ont fait l'objet de recherches et de développements approfondis, avec des modèles de pointe tels que GPT-4, Meta LLaMa et Alpaca repoussant les limites du traitement du langage naturel et du matériel nécessaire pour les exécuter. . L'exécution de l'inférence sur ces modèles peut être difficile sur le plan informatique, nécessitant un matériel puissant pour fournir des résultats en temps réel.

Ces derniers mois, de grands modèles de langage ont fait l'objet de recherches et de développements approfondis, avec des modèles de pointe tels que GPT-4, Meta LLaMa et Alpaca repoussant les limites du traitement du langage naturel et du matériel nécessaire pour les exécuter. . L'exécution de l'inférence sur ces modèles peut être difficile sur le plan informatique, nécessitant un matériel puissant pour fournir des résultats en temps réel.

Dans le laboratoire d'examen du stockage, nous avons chargé deux GPU NVIDIA RTX 8000 d'exécuter le modèle LLaMa de Meta pour voir comment ils fonctionnaient lors de l'exécution de l'inférence sur des modèles de langage volumineux. Nous avons utilisé le Lenovo P920 en tant qu'hôte pour les cartes, minimisant les goulots d'étranglement. La RTX 8000 est une carte graphique haut de gamme capable d'être utilisée dans les applications d'IA et d'apprentissage en profondeur, et nous les avons spécifiquement choisies hors de la pile grâce aux 48 Go de mémoire GDDR6 et aux 4608 cœurs CUDA sur chaque carte, et aussi Kevin accumule tous les A6000s.

Meta LLaMA est un modèle de langage à grande échelle formé sur un ensemble diversifié de textes Internet. Il est accessible au public et fournit des résultats de pointe dans diverses tâches de traitement du langage naturel. Dans cet article, nous fournirons un guide étape par étape sur la façon dont nous avons configuré et exécuté l'inférence LLaMA sur les GPU NVIDIA, cela n'est pas garanti pour tout le monde.

Exigences Meta LLaMa

Avant de commencer, nous devons nous assurer que les exigences suivantes sont installées :

• GPU NVIDIA avec un minimum de 16 Go de VRAM
• Pilotes NVIDIA installés (au moins version 440.33)
• CUDA Toolkit installé (au moins la version 10.1)
• Anaconda installé
• PyTorch installé (au moins la version 1.7.1)
• Espace disque; l'ensemble des points de contrôle LLaMa pousse plus de 200 To.

Remarque : Il est recommandé d'avoir un environnement Anaconda dédié pour LLaMA, nous en avons quelques-uns sur le banc d'essai afin que nous puissions jouer avec les packages et les paramètres et ne pas arroser l'installation de base.

Étapes pour exécuter l'inférence Meta LLaMA sur les GPU NVIDIA

1. Téléchargez le référentiel LLaMA : La première étape consiste à cloner le référentiel LLaMA à partir de GitHub.

2. Obtenez le point de contrôle LLaMA et le tokenizer : Visitez la page GitHub et remplissez le formulaire Google lié pour accéder au téléchargement. D'autres LLM sont disponibles, comme Alpaca. À cette fin, nous supposerons que l'accès est disponible aux fichiers LLaMa.

3. Répertoriez et installez les programmes requis pour LLaMa en exécutant la commande suivante depuis le répertoire du référentiel cloné :

4. Configurez le script d'inférence : Le plus example.py Le script fourni dans le référentiel LLaMA peut être utilisé pour exécuter l'inférence LLaMA. Le script peut être exécuté sur un nœud mono ou multi-gpu avec torchrun et produira des complétions pour deux invites prédéfinies.

Ouvert example.py et définissez les paramètres suivants en fonction de vos préférences. Les descriptions de chaque paramètre et leur action sont répertoriées ci-dessous.

• --max_seq_len: longueur maximale de la séquence (la valeur par défaut est 2048)
• --max_batch_size: taille de lot maximale (la valeur par défaut est 8)
• --gen_length: longueur de génération (la valeur par défaut est 512)
• --temperature: température de génération (la valeur par défaut est 1.0)
• --top_p: échantillonnage top-p (la valeur par défaut est 0.9)

Par exemple, pour exécuter l'inférence LLaMA sur un seul GPU avec des fichiers de point de contrôle et de tokenizer dans le répertoire /path/to/files, utilisez la commande suivante:

Noter la nproc_per_node L'argument dépend de la taille du modèle et du nombre de GPU requis pour les points de contrôle LLaMa par défaut. Reportez-vous au tableau suivant pour définir la valeur appropriée pour votre système et le modèle que vous utilisez :

Modèle	GPU requis
7B	1
13M	2
33M	4
65M	8

Dans l'exemple ci-dessous, nous avons utilisé les invites standard du fichier d'exemple, mais joué avec le temperature et top_p variables, donnant des résultats intéressants. Nous avons également augmenté la longueur de la réponse.

Décomposition du fichier example.py et des variables que vous devez connaître

La plupart d'entre eux sont prédéfinis dans le modèle et n'ont pas besoin d'être ajustés ; Cependant, si vous vous lancez dans l'utilisation des LLM et de l'inférence, voici quelques informations pratiques qui détaillent ce que font les drapeaux et les commutateurs.

1. local_rank: le rang du GPU actuel (processus) dans le groupe de GPU utilisés pour le parallélisme des modèles. Ceci est réglé automatiquement.
2. world_size: nombre total de GPU utilisés pour le parallélisme des modèles. Ceci est réglé automatiquement.
3. ckpt_dir: Le répertoire contenant les points de contrôle du modèle. Ceci est défini au moment de l'exécution.
4. tokenizer_path: chemin d'accès au tokenizer utilisé pour prétraiter le texte. Ceci est défini au moment de l'exécution.
5. temperature: Un paramètre qui contrôle le caractère aléatoire du texte généré (des valeurs plus élevées rendent la sortie plus aléatoire et des valeurs plus faibles la rendent plus ciblée).
6. top_p: Un paramètre qui contrôle la stratégie d'échantillonnage du noyau, qui est une méthode de génération de texte qui sélectionne uniquement les jetons les plus probables avec une probabilité cumulée d'au plus top_p.
7. max_seq_len: La longueur de séquence maximale pour l'entrée et la sortie du modèle. Vous pouvez l'ajuster pour réduire vos besoins en VRAM.
8. max_batch_size: nombre maximal de séquences d'entrée que le modèle peut traiter en parallèle. Vous pouvez l'ajuster pour réduire vos besoins en VRAM.
9. prompts: une liste d'invites de saisie pour que le modèle génère du texte basé sur.
10. results: une liste de texte généré correspondant à chaque invite de saisie.

Réflexions finales

Nos tests ont montré que les GPU RTX 8000 pouvaient offrir des performances impressionnantes, avec des temps d'inférence allant de quelques secondes à environ une minute, selon les paramètres du modèle et la taille d'entrée. Les GPU pouvaient gérer de grandes tailles de lots et exécuter des inférences sur plusieurs modèles simultanément sans aucun ralentissement notable.

L'un des avantages de l'utilisation des GPU pour l'inférence est qu'ils peuvent être facilement mis à l'échelle en ajoutant plus de GPU au système. Cela permet d'exécuter des modèles encore plus grands en temps réel, permettant de nouvelles applications dans des domaines tels que les chatbots, les systèmes de questions-réponses et l'analyse des sentiments.

Alpaca est un modèle de langage d'IA compact créé par une équipe d'informaticiens de l'Université de Stanford. Il est construit sur le modèle LLaMA 7B de Meta, qui compte 7 milliards de paramètres et a été formé à l'aide d'une grande quantité de texte provenant du Web. Pour affiner Alpaca, 52,000 003 démonstrations de suivi d'instructions ont été générées avec le modèle text-davinci-600 d'OpenAI, un modèle polyvalent capable d'exécuter diverses tâches basées sur des instructions en langage naturel. L'alpaga est meilleur pour suivre les instructions et produire du texte à diverses fins, y compris la rédaction de résumés, d'histoires et de blagues. Avec un coût de formation inférieur à XNUMX $, Alpaca est conçu pour être à la fois rentable et facilement reproductible. De manière très impressionnante, il convient de mentionner qu'Alpaca peut être exécuté même sur un ordinateur portable. Nous entraînons un modèle similaire à Alpaca en utilisant les méthodes de Stanford, mais avec notre propre touche.

Ce n'est qu'une des façons dont nous travaillons avec les dernières avancées technologiques du laboratoire, et grâce à de puissants GPU NVIDIA, nous pouvons faire encore plus que de simples inférences ; nous nous entraînons. Soyez à l'affût du prochain article sur les modèles de réglage fin comme Meta LLaMa.

S'engager avec StorageReview 

Newsletter |  YouTube | Podcast iTunes/Spotify | Instagram | Twitter | TikTok | Flux RSS