Tous les exemples de code présentés sur cette page sont en Python.
Essayez Hugging Face Hub avec Weave dans Google Colab
Vous souhaitez tester Hugging Face Hub et Weave sans configuration préalable ? Vous pouvez essayer les exemples de code présentés ici sous la forme d’un notebook Jupyter dans Google Colab.
huggingface_hub fournit une interface unifiée pour exécuter l’inférence sur plusieurs services pour les modèles hébergés sur le Hub. Vous pouvez appeler ces modèles à l’aide de InferenceClient.
Weave capture automatiquement les traces pour InferenceClient. Pour commencer le suivi, appelez weave.init() et utilisez la bibliothèque normalement.
-
Avant de pouvoir utiliser
huggingface_hub avec Weave, vous devez installer les bibliothèques nécessaires ou les mettre à jour vers leur dernière version. La commande suivante installe ou met à jour huggingface_hub et weave vers la dernière version, s’ils sont déjà installés, tout en réduisant la sortie d’installation.
pip install -U huggingface_hub weave -qqq
-
Pour utiliser l’inférence avec un modèle sur le Hugging Face Hub, configurez votre User Access Token. Vous pouvez définir ce token depuis votre page Settings de Hugging Face Hub ou par programmation. L’exemple de code suivant invite l’utilisateur à saisir son
HUGGINGFACE_TOKEN et définit ce token comme variable d’environnement.
import os
import getpass
os.environ["HUGGINGFACE_TOKEN"] = getpass.getpass("Enter your Hugging Face Hub Token: ")
Stocker les traces des applications basées sur des modèles de langage dans un emplacement centralisé est essentiel pendant le développement comme en production. Ces traces facilitent le débogage et constituent de précieux Datasets pour améliorer votre application.
Weave capture automatiquement les traces de l’InferenceClient. Pour commencer le suivi, initialisez Weave en appelant weave.init(), puis utilisez la bibliothèque comme d’habitude.
L’exemple suivant montre comment consigner les appels d’inférence vers le Hugging Face Hub à l’aide de Weave :
import weave
from huggingface_hub import InferenceClient
# Initialiser Weave
weave.init(project_name="quickstart-huggingface")
# Initialiser le client d'inférence Hugging Face
huggingface_client = InferenceClient(
api_key=os.environ.get("HUGGINGFACE_TOKEN")
)
# Effectuer un appel d'inférence de complétion de chat vers le 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": "Décrivez cette image en une phrase."},
],
}
],
max_tokens=500,
seed=42,
)
Weave affiche également l’appel sous forme de vue de chat dans l’UI, avec l’historique complet de la conversation avec le modèle.
Pour mieux comprendre comment les données circulent dans votre application, vous pouvez utiliser @weave.op pour suivre les appels de fonction. Cela enregistre les entrées, les sorties et la logique d’exécution, ce qui facilite le débogage et l’analyse des performances.
En imbriquant plusieurs ops, vous pouvez créer une arborescence structurée de fonctions suivies. Weave versionne aussi automatiquement votre code, en conservant les états intermédiaires au fil de vos expérimentations, même avant de valider vos modifications dans Git.
Pour commencer le suivi, ajoutez le décorateur @weave.op aux fonctions que vous souhaitez suivre.
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é.
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.op, ce qui vous permet d’analyser les détails d’exécution dans la Weave UI.
Weave capture et visualise également l’exécution des fonctions, ce qui vous aide à comprendre le flux de données et la logique au sein de votre application.Utilisez des Models pour l’expérimentation
Model permet de capturer et d’organiser les détails expérimentaux, comme les prompts système et les configurations de modèle, afin de comparer facilement différentes itérations.
En plus de la gestion des versions du code et de la capture des entrées/sorties, un Model stocke des paramètres structurés qui contrôlent le comportement de l’application. Il est ainsi plus facile de suivre quelles configurations ont produit les meilleurs résultats. Vous pouvez également intégrer un Model Weave à Weave Serve et aux Évaluations pour obtenir des informations supplémentaires.
L’exemple ci-dessous définit un modèle CityVisitRecommender pour des recommandations de voyage. Chaque modification de ses paramètres génère une nouvelle version, ce qui facilite l’expérimentation.
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"))
