> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Hugging Face Hub
> Intégrez Hugging Face Hub à W&B Weave pour suivre et analyser vos applications de machine learning
Tous les exemples de code présentés sur cette page sont en Python.
Cette page explique comment intégrer [Hugging Face Hub](https://huggingface.co/) à W\&B Weave pour suivre et analyser vos applications de machine learning. Vous apprendrez à journaliser les inférences de modèles, à surveiller les appels de fonctions et à organiser vos expériences grâce aux fonctionnalités de traçage et de gestion des versions de Weave. En suivant les exemples fournis, vous pourrez recueillir des informations utiles, déboguer vos applications et comparer différentes configurations de modèles, le tout depuis l’interface web de Weave.
**Essayez Hugging Face Hub avec Weave dans Google Colab**
Vous souhaitez expérimenter Hugging Face Hub et Weave sans rien configurer ? Vous pouvez essayer les exemples de code présentés ici sous forme de Jupyter Notebook dans Google Colab.
Aperçu
Hugging Face Hub est une plateforme de machine learning destinée aux créateurs et aux collaborateurs, qui propose une vaste collection de modèles pré-entraînés et de datasets pour de nombreux types de projets.
La bibliothèque Python `huggingface_hub` fournit une interface unifiée pour exécuter l’inférence sur plusieurs services avec les modèles hébergés sur le Hub. Vous pouvez appeler ces modèles à l’aide de [`InferenceClient`](https://huggingface.co/docs/huggingface_hub/en/package_reference/inference_client).
Weave capture automatiquement les traces d’`InferenceClient`. Pour commencer à suivre vos appels, appelez `weave.init()` et utilisez la bibliothèque comme d’habitude.
Prérequis
Avant de commencer, effectuez les étapes de configuration suivantes pour installer les bibliothèques requises et configurer l’accès au Hugging Face Hub :
1. Avant de pouvoir utiliser `huggingface_hub` avec Weave, vous devez installer les bibliothèques nécessaires ou les mettre à niveau vers leurs dernières versions. La commande suivante installe `huggingface_hub` et `weave`, ou les met à niveau vers la dernière version s’ils sont déjà installés, tout en limitant la sortie de l’installation.
```python lines theme={"system"}
pip install -U huggingface_hub weave -qqq
```
2. Pour utiliser l’inférence avec un modèle du Hugging Face Hub, définissez votre [jeton d’accès utilisateur](https://huggingface.co/docs/hub/security-tokens). Vous pouvez définir le jeton depuis la [page des paramètres de votre compte Hugging Face Hub](https://huggingface.co/login?next=%2Fsettings%2Ftokens) ou par programmation. L’exemple de code suivant vous invite à saisir votre `HUGGINGFACE_TOKEN`, puis le définit comme variable d’environnement.
```python lines theme={"system"}
import os
import getpass
os.environ["HUGGINGFACE_TOKEN"] = getpass.getpass("Enter your Hugging Face Hub Token: ")
```
Traçage de base
Il est essentiel de stocker les traces des applications de modèles de langage dans un emplacement centralisé, aussi bien en développement qu’en production. Ces traces facilitent le débogage et servent de datasets pour améliorer votre application.
Weave capture automatiquement les traces de `InferenceClient`. Pour commencer à suivre, initialisez Weave en appelant `weave.init()`, puis utilisez la bibliothèque comme d’habitude.
L’exemple suivant montre comment journaliser avec Weave les appels d’inférence vers le Hugging Face Hub :
```python lines theme={"system"}
import weave
from huggingface_hub import InferenceClient
# Initialiser Weave
weave.init(project_name="quickstart-huggingface")
# Initialiser le client Hugging Face Inference
huggingface_client = InferenceClient(
api_key=os.environ.get("HUGGINGFACE_TOKEN")
)
# Envoyer un appel d’inférence de complétion de chat au Hugging Face Hub avec le modèle Llama-3.2-11B-Vision-Instruct
image_url = "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
response = huggingface_client.chat_completion(
model="meta-llama/Llama-3.2-11B-Vision-Instruct",
messages=[
{
"role": "user",
"content": [
{"type": "image_url", "image_url": {"url": image_url}},
{"type": "text", "text": "Describe this image in one sentence."},
],
}
],
max_tokens=500,
seed=42,
)
```
Une fois le code précédent exécuté, Weave suit et journalise tous les appels LLM effectués avec le Hugging Face Inference Client. Vous pouvez consulter ces traces dans l’interface web de Weave.
Weave journalise chaque appel d’inférence et fournit des détails sur les entrées, les sorties et les métadonnées.
Weave affiche également l’appel sous forme de vue chat dans l’interface utilisateur, avec l’historique de conversation complet avec le modèle.
Tracer une fonction
Pour mieux comprendre la circulation des données dans votre application, vous pouvez utiliser `@weave.op` afin de suivre les appels de fonctions. Les entrées, les sorties et la logique d’exécution sont ainsi capturées, ce qui facilite le débogage et l’analyse des performances.
En imbriquant plusieurs ops, vous pouvez construire une arborescence structurée de fonctions suivies. Weave versionne également votre code automatiquement et conserve les états intermédiaires au fil de vos expériences, avant même que vous ne validiez vos modifications dans Git.
Pour commencer à suivre vos fonctions, décorez celles que vous souhaitez suivre avec `@weave.op`.
Dans l’exemple suivant, Weave suit trois fonctions : `generate_image`, `check_image_correctness` et `generate_image_and_check_correctness`. Ces fonctions génèrent une image et vérifient si elle correspond à un prompt donné.
```python lines theme={"system"}
import base64
from PIL import Image
def encode_image(pil_image):
import io
buffer = io.BytesIO()
pil_image.save(buffer, format="JPEG")
buffer.seek(0)
encoded_image = base64.b64encode(buffer.read()).decode("utf-8")
return f"data:image/jpeg;base64,{encoded_image}"
@weave.op
def generate_image(prompt: str):
return huggingface_client.text_to_image(
prompt=prompt,
model="black-forest-labs/FLUX.1-schnell",
num_inference_steps=4,
)
@weave.op
def check_image_correctness(image: Image.Image, image_generation_prompt: str):
return huggingface_client.chat_completion(
model="meta-llama/Llama-3.2-11B-Vision-Instruct",
messages=[
{
"role": "user",
"content": [
{"type": "image_url", "image_url": {"url": encode_image(image)}},
{
"type": "text",
"text": f"Is this image correct for the prompt: {image_generation_prompt}? Answer with only one word: yes or no",
},
],
}
],
max_tokens=500,
seed=42,
).choices[0].message.content
@weave.op
def generate_image_and_check_correctness(prompt: str):
image = generate_image(prompt)
return {
"image": image,
"is_correct": check_image_correctness(image, prompt),
}
response = generate_image_and_check_correctness("A cute puppy")
```
Weave journalise désormais tous les appels de fonction encapsulés avec `@weave.op`, ce qui vous permet d’analyser le détail de leur exécution dans l’interface Weights & Biases.
Weave capture et visualise également l’exécution des fonctions, pour vous aider à comprendre le flux de données et la logique de votre application.
Utiliser les `Model` pour l’expérimentation
La gestion des expériences LLM peut s’avérer complexe lorsque plusieurs composants entrent en jeu. La [classe `Model`](/fr/products/wandb/weave/guides/core-types/models) de Weave permet de capturer et d’organiser les détails de vos expériences, tels que les prompts système et les configurations de modèle, afin de comparer différentes itérations.
En plus de gérer les versions du code et de capturer les entrées et les sorties, un `Model` stocke des paramètres structurés qui contrôlent le comportement de l’application. Vous pouvez ainsi identifier les configurations qui ont produit les meilleurs résultats. Vous pouvez également intégrer un `Model` Weave à Weave [Serve](/fr/products/wandb/weave/guides/tools/serve) et aux [Évaluations](/fr/products/wandb/weave/guides/evaluation/scorers) pour approfondir votre analyse.
L’exemple suivant définit un modèle `CityVisitRecommender` destiné aux recommandations de voyage. Chaque modification de ses paramètres génère une nouvelle version, ce qui facilite l’expérimentation itérative.
```python lines theme={"system"}
import rich
class CityVisitRecommender(weave.Model):
model: str
temperature: float = 0.7
max_tokens: int = 500
seed: int = 42
@weave.op()
def predict(self, city: str) -> str:
return huggingface_client.chat_completion(
model=self.model,
messages=[
{
"role": "system",
"content": "You are a helpful assistant meant to suggest places to visit in a city",
},
{"role": "user", "content": city},
],
max_tokens=self.max_tokens,
temperature=self.temperature,
seed=self.seed,
).choices[0].message.content
city_visit_recommender = CityVisitRecommender(
model="meta-llama/Llama-3.2-11B-Vision-Instruct",
temperature=0.7,
max_tokens=500,
seed=42,
)
rich.print(city_visit_recommender.predict("New York City"))
rich.print(city_visit_recommender.predict("Paris"))
```
Weave journalise automatiquement les modèles et suit leurs différentes versions, ce qui vous permet d’analyser leurs performances et l’historique de vos expériences.
