Pour déployer une famille de modèles Lama à l'aide de NVIDIA NIM sur votre propre cloud ou machine locale, suivez ces étapes :

1. Configurer l'environnement : Si vous exécutez le modèle sur votre machine locale, installez le moteur Docker et le toolkit de conteneurs NVIDIA. Les liens vers ces éléments sont fournis dans la description de la vidéo.

2. Obtenir la clé API : Inscrivez-vous à un compte NVIDIA pour générer votre clé API et votre clé personnelle. Elles seront nécessaires pour interagir avec le serveur distant.

3. Exécuter le conteneur Docker : Utilisez la commande Docker fournie pour exécuter le conteneur, en spécifiant le nom du conteneur, l'utilisation du GPU, la clé API, l'emplacement du cache du modèle et le port. Cela téléchargera et configurera le modèle Lama 3 8 milliards d'instructions.

4. Interagir avec le modèle : Utilisez la commande cURL fournie pour interagir avec le modèle déployé. Cette commande suit la norme de l'API OpenAI, vous permettant d'utiliser le client OpenAI pour l'interaction.

5. Tester la résistance de l'API : Utilisez un script Python avec la bibliothèque requests pour envoyer plusieurs requêtes simultanées au point de terminaison de l'API et surveiller l'utilisation du GPU et le débit.

6. Utiliser le client API OpenAI : Démontrez comment utiliser le client API OpenAI avec NVIDIA NIM, en mettant à jour l'URL de base et d'autres paramètres pour correspondre au modèle déployé.

Pour accéder à NVIDIA Launchpad et au tableau de bord des métriques GPU, suivez ces étapes :

1. Dans le cadre d'NVIDIA Launchpad, vous avez accès à un IDE de code, qui est Visual Studio Code. Vous pouvez utiliser cet IDE pour interagir avec l'instance GPU et déployer le modèle Llama 3 8 milliards d'instructions.

2. Le tableau de bord des métriques GPU est un tableau de bord Grafana qui fournit des informations détaillées sur l'utilisation et les performances du GPU. Vous pouvez accéder à ce tableau de bord pour surveiller l'utilisation du GPU, la version CUDA, les pilotes GPU et d'autres métriques pertinentes.

3. Le tableau de bord Grafana vous donne une représentation visuelle de l'utilisation du GPU au fil du temps, vous permettant de suivre les performances et d'optimiser le déploiement en conséquence.

4. Vous pouvez utiliser la commande watch dans le terminal pour surveiller l'utilisation du GPU en temps réel. La commande watch -n 1 nvidia-smi mettra à jour l'utilisation du GPU toutes les secondes, vous donnant une vue en direct de l'utilisation du GPU.

5. Le tableau de bord des métriques GPU et les outils de surveillance en temps réel vous permettent de comprendre les caractéristiques de performance du déploiement du modèle Llama 3 8 milliards d'instructions, vous aidant à optimiser l'utilisation des ressources et à assurer une inférence efficace.

Pour déployer le modèle Llama 3 8 milliards d'instructions à l'aide de NVIDIA NIM, suivez ces étapes :

1. Ouvrez l'IDE fourni et assurez-vous d'avoir accès à un GPU H100.
2. Configurez votre clé API en vous inscrivant à un compte NVIDIA et en générant les clés nécessaires.
3. Exécutez la commande Docker suivante pour démarrer le conteneur NVIDIA NIM :

docker run -it --gpus all -e NVIDIA_API_KEY=$NVIDIA_API_KEY -p 8000:8000 --name llama-3-8b-instruct nvcr.io/nvidia/nim:latest --model-name llama-3-8b-instruct

Cette commande :

• Crée un conteneur Docker nommé "llama-3-8b-instruct"
• Utilise tous les GPU disponibles sur le système
• Définit la variable d'environnement NVIDIA_API_KEY
• Expose le port 8000 pour le serveur NIM
• Utilise le modèle "llama-3-8b-instruct" du catalogue NVIDIA NIM

4. Une fois le conteneur en cours d'exécution, vous pouvez utiliser la commande cURL fournie pour interagir avec le modèle :

curl -X POST -H "Content-Type: application/json" -d '{"model": "llama-3-8b-instruct", "prompt": "Raconte-moi une blague.", "max_tokens": 1000, "temperature": 0.7, "top_p": 0.95, "stop": ["\n"]}' http://localhost:8000/v1/completions

Cette commande cURL envoie une requête au serveur NIM en cours d'exécution sur localhost:8000 pour générer une réponse pour l'invite "Raconte-moi une blague."

5. Pour tester la résistance du point de terminaison API, vous pouvez exécuter le script Python test_server.py fourni. Ce script enverra plusieurs requêtes simultanées au serveur NIM et surveillera l'utilisation du GPU.

6. Enfin, vous pouvez également utiliser le client API OpenAI pour interagir avec le serveur NIM en mettant à jour l'URL de base pour pointer vers l'adresse et le port du serveur NIM.

En suivant ces étapes, vous pourrez déployer avec succès le modèle Llama 3 8 milliards d'instructions à l'aide du conteneur Docker NVIDIA NIM et tester ses performances.

Pour interagir avec l'API NVIDIA NIM, nous pouvons utiliser une simple commande cURL. La commande cURL fournit les éléments suivants :

• Effectue une requête POST sur l'hôte local au port 8000, où le serveur NVIDIA NIM est en cours d'exécution.
• Utilise l'API compatible OpenAI, afin que nous puissions utiliser le client OpenAI pour interagir avec le serveur NIM.
• Spécifie le modèle Llama 3 8 milliards d'instructions à utiliser.
• Définit la structure du message similaire à ce qu'OpenAI attend.
• Permet de définir des paramètres supplémentaires comme max_tokens et temperature.

Voici la commande cURL :

curl -X POST -H "Content-Type: application/json" -d '{"model": "nlp/lama-3-8b-instruct", "messages": [{"role": "user", "content": "Raconte-moi une blague"}], "max_tokens": 1000, "temperature": 0.7}' http://localhost:8000/v1/chat/completions

Cette commande cURL enverra une requête au serveur NVIDIA NIM, qui générera alors une réponse à partir du modèle Llama 3 8 milliards d'instructions. La réponse sera diffusée en continu, chaque jeton étant affiché au fur et à mesure de sa génération.

Pour tester davantage le point de terminaison de l'API, nous pouvons utiliser un script Python qui utilise la bibliothèque requests pour effectuer plusieurs requêtes simultanées. Ce script enverra 50 requêtes de génération de blagues en parallèle et surveillera l'utilisation du GPU et le débit.

Pour tester la résistance du point de terminaison de l'API NVIDIA NIM, nous utiliserons un simple script Python qui s'appuie sur la bibliothèque requests pour effectuer plusieurs requêtes simultanées à l'API. Voici comment cela fonctionne :

1. Nous définissons l'URL du point de terminaison de l'API, qui dans ce cas est l'hôte local puisque nous exécutons le serveur localement. Si vous deviez déployer cela sur un serveur distant, vous devriez utiliser l'adresse IP externe et activer le transfert de port.

2. Nous définissons les en-têtes nécessaires, y compris l'en-tête Content-Type sur application/json.

3. Nous créons la charge utile, qui inclut le nom du modèle ("model": "llama-3-8b-instruct"), l'invite ("prompt": "Raconte-moi 50 blagues."), et d'autres paramètres comme max_tokens, temperature et stop.

4. Nous définissons une fonction send_requests() qui envoie les requêtes à l'aide de la méthode requests.post() et de l'URL, des en-têtes et de la charge utile que nous avons définis précédemment.

5. Nous utilisons le multithreading pour exécuter plusieurs instances de la fonction send_requests() de manière concurrente, simulant un volume élevé de requêtes au point de terminaison de l'API.

6. Nous surveillons l'utilisation du GPU en temps réel à l'aide de la commande watch et de l'outil nvidia-smi, qui fournit des informations sur l'utilisation du GPU.

La sortie montre que le point de terminaison de l'API est capable de gérer un nombre important de requêtes simultanées, avec un débit moyen d'environ 2 500 jetons par seconde. L'utilisation du GPU reste également relativement élevée, indiquant que NVIDIA NIM exploite efficacement les ressources matérielles pour offrir une inférence haute performance.

Ce test de résistance démontre la mise à l'échelle et les performances de la solution NVIDIA NIM, en faire une option intéressante pour le déploiement de modèles de langage de grande taille dans un environnement de production.

Pour utiliser le client API OpenAI avec NVIDIA NIM, suivez ces étapes :

1. Modifiez l'URL de base pour qu'elle corresponde à l'URL de votre instance NVIDIA NIM. Dans cet exemple, nous l'exécutons sur localhost:8000 :

openai.api_base = "http://localhost:8000"

2. Vous n'avez pas besoin de fournir la clé API, car NVIDIA NIM gère l'authentification.

3. Définissez le modèle sur le modèle hébergé par NVIDIA NIM, dans ce cas, "meta-llama-38b-instruct" :

model = "meta-llama-38b-instruct"

4. Définissez les autres paramètres, comme le nombre maximum de jetons à générer, la température et si vous voulez diffuser les réponses en continu :

response = openai.ChatCompletion.create(
    model=model,
    messages=[{"role": "user", "content": "Raconte-moi 50 blagues différentes"}],
    max_tokens=1024,
    temperature=0.7,
    stream=True,
)

5. Parcourez la réponse en continu et affichez le texte généré :

for chunk in response:
    print(chunk.choices[0].text, end="")

Cette approche vous permet de tirer parti des performances et de la facilité de déploiement offertes par NVIDIA NIM tout en utilisant le client API OpenAI familier. La réponse en continu vous assure d'obtenir le texte généré en temps réel, offrant une expérience utilisateur réactive.

Dans cette vidéo, nous avons exploré comment déployer un modèle Lama 3 8 milliards d'instructions à l'aide de NVIDIA NIM sur votre propre cloud ou machine locale. NVIDIA NIM est un ensemble de microservices développés par NVIDIA qui accélère le déploiement des modèles de base, y compris les modèles de langage et d'autres modèles d'IA.

Nous avons passé en revue les étapes pour configurer l'environnement NVIDIA NIM, y compris la génération de la clé API et l'exécution du conteneur Docker pour déployer le modèle Lama 3. Nous avons également testé les performances du modèle déployé en envoyant plusieurs requêtes simultanément et en surveillant l'utilisation du GPU et le débit.

De plus, nous avons montré comment utiliser le client API OpenAI pour interagir avec le modèle déployé par NVIDIA NIM, démontrant la compatibilité avec la norme de l'API OpenAI.

Dans l'ensemble, NVIDIA NIM offre un moyen pratique et efficace de déployer des modèles de langage de grande taille dans un environnement de production. La possibilité de tirer parti de la pile matérielle et logicielle de NVIDIA peut entraîner des améliorations de performances significatives par rapport à d'autres options de déploiement. Si vous êtes intéressé par l'exploration d'autres options de déploiement pour vos projets, n'hésitez pas à vous abonner à la chaîne pour obtenir du contenu à venir sur VLLM et d'autres sujets connexes.