06.NVIDIA.md

February 1, 2026 · View on GitHub

Famille Phi dans NVIDIA NIM

NVIDIA NIM est un ensemble de microservices faciles à utiliser, conçus pour accélérer le déploiement de modèles d’IA générative dans le cloud, les centres de données et les stations de travail. Les NIM sont classés par famille de modèles et par modèle individuel. Par exemple, NVIDIA NIM pour les grands modèles de langage (LLM) apporte la puissance des LLM de pointe aux applications d’entreprise, offrant des capacités inégalées de traitement et de compréhension du langage naturel.

NIM facilite pour les équipes IT et DevOps l’auto-hébergement de grands modèles de langage (LLM) dans leurs propres environnements gérés, tout en fournissant aux développeurs des API standards de l’industrie qui leur permettent de créer des copilotes, chatbots et assistants IA puissants capables de transformer leur activité. En tirant parti de l’accélération GPU de pointe de NVIDIA et d’un déploiement évolutif, NIM offre la voie la plus rapide vers l’inférence avec des performances inégalées.

Vous pouvez utiliser NVIDIA NIM pour inférer les modèles de la famille Phi

nim

Exemples - Phi-3-Vision dans NVIDIA NIM

Imaginez que vous avez une image (demo.png) et que vous souhaitez générer un code Python qui traite cette image et enregistre une nouvelle version (phi-3-vision.jpg).

Le code ci-dessus automatise ce processus en :

Configurant l’environnement et les paramètres nécessaires.
Créant une invite qui demande au modèle de générer le code Python requis.
Envoyant l’invite au modèle et récupérant le code généré.
Extrait et exécute le code généré.
Affichant les images originale et traitée.

Cette approche exploite la puissance de l’IA pour automatiser les tâches de traitement d’image, rendant leur réalisation plus simple et plus rapide.

Solution de code exemple

Décomposons ce que fait le code étape par étape :

Installer le package requis :
```
!pip install langchain_nvidia_ai_endpoints -U
```
Cette commande installe le package langchain_nvidia_ai_endpoints, en s’assurant qu’il est à jour.
Importer les modules nécessaires :
```
from langchain_nvidia_ai_endpoints import ChatNVIDIA
import getpass
import os
import base64
```
Ces imports chargent les modules nécessaires pour interagir avec les endpoints NVIDIA AI, gérer les mots de passe de manière sécurisée, interagir avec le système d’exploitation, et encoder/décoder des données en base64.
Configurer la clé API :
```
if not os.getenv("NVIDIA_API_KEY"):
    os.environ["NVIDIA_API_KEY"] = getpass.getpass("Enter your NVIDIA API key: ")
```
Ce code vérifie si la variable d’environnement NVIDIA_API_KEY est définie. Sinon, il invite l’utilisateur à saisir sa clé API de façon sécurisée.
Définir le modèle et le chemin de l’image :
```
model = 'microsoft/phi-3-vision-128k-instruct'
chat = ChatNVIDIA(model=model)
img_path = './imgs/demo.png'
```
Cela définit le modèle à utiliser, crée une instance de ChatNVIDIA avec ce modèle, et définit le chemin vers le fichier image.
Créer l’invite textuelle :
```
text = "Please create Python code for image, and use plt to save the new picture under imgs/ and name it phi-3-vision.jpg."
```
Cette étape définit une invite textuelle demandant au modèle de générer un code Python pour traiter une image.

Encoder l’image en base64 :

with open(img_path, "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode()
image = f'<img src="data:image/png;base64,{image_b64}" />'

Ce code lit le fichier image, l’encode en base64, et crée une balise HTML image avec les données encodées.

Combiner le texte et l’image dans l’invite :
```
prompt = f"{text} {image}"
```
Cela combine l’invite textuelle et la balise image HTML en une seule chaîne.
Générer le code avec ChatNVIDIA :
```
code = ""
for chunk in chat.stream(prompt):
    print(chunk.content, end="")
    code += chunk.content
```
Ce code envoie l’invite au modèle ChatNVIDIA et récupère le code généré par morceaux, affichant et ajoutant chaque morceau à la variable code.
Extraire le code Python du contenu généré :
```
begin = code.index('```python') + 9  
code = code[begin:]  
end = code.index('```')
code = code[:end]
```
Cette étape extrait le code Python réel du contenu généré en supprimant la mise en forme markdown.
Exécuter le code généré :
```
import subprocess
result = subprocess.run(["python", "-c", code], capture_output=True)
```
Ce code exécute le code Python extrait en tant que sous-processus et capture sa sortie.

Afficher les images :

from IPython.display import Image, display
display(Image(filename='./imgs/phi-3-vision.jpg'))
display(Image(filename='./imgs/demo.png'))

Ces lignes affichent les images à l’aide du module IPython.display.

Avertissement :
Ce document a été traduit à l’aide du service de traduction automatique Co-op Translator. Bien que nous nous efforcions d’assurer l’exactitude, veuillez noter que les traductions automatiques peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d’origine doit être considéré comme la source faisant foi. Pour les informations critiques, une traduction professionnelle réalisée par un humain est recommandée. Nous déclinons toute responsabilité en cas de malentendus ou de mauvaises interprétations résultant de l’utilisation de cette traduction.