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 à W&B Weave pour suivre et analyser vos applications de machine learning. Vous apprendrez à consigner les inférences des modèles, à surveiller les appels de fonction et à organiser les expériences grâce aux capacités de traçage et de gestion des versions de Weave. En suivant les exemples fournis, vous pourrez obtenir des informations, déboguer vos applications et comparer différentes configurations de modèles, le tout dans l’interface web de Weave.

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.

​

Aperçu

Hugging Face Hub est une plateforme de machine learning pour les créateurs et les collaborateurs, qui propose une grande 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 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.

​

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 à 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
   

2. 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 vous invite à saisir votre 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: ")
   

​

Traçage de base

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 des 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 Hugging Face Inference Client
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": "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 de chat dans l’UI, avec l’historique complet de la conversation avec le modèle.

​

Tracer une fonction

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 que vous ne validiez 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 journalise désormais tous les appels de fonction encapsulés avec @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

La gestion des expériences avec des LLM peut être complexe lorsque plusieurs composants entrent en jeu. La classe Weave Model permet de capturer et d’organiser les détails expérimentaux, comme les prompts système et les configurations de modèle, vous permettant de comparer différentes itérations.

En plus de la gestion des versions du code et de la capture des entrées et des sorties, un Model stocke des paramètres structurés qui contrôlent le comportement de l’application. Cela vous aide à 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 suivant définit un modèle CityVisitRecommender pour des recommandations de voyage. Chaque modification de ses paramètres génère une nouvelle version, favorisant une expérimentation itérative.

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 afin que vous puissiez analyser les performances et l’historique des expériences.