Hugging Face Hub - CoreWeave Docs

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

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.
pip install -U huggingface_hub weave -qqq
Pour utiliser l’inférence avec un modèle du Hugging Face Hub, définissez votre jeton d’accès utilisateur. Vous pouvez définir le jeton depuis la page des paramètres de votre compte Hugging Face Hub ou par programmation. L’exemple de code suivant vous invite à saisir votre HUGGINGFACE_TOKEN, puis le définit comme variable d’environnement.
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 :

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. Vue chat de Weave dans l’interface utilisateur, avec l’historique de conversation complet avec le modèle

Vue chat de Weave dans l’interface utilisateur, avec l’historique de conversation complet avec le modèle

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é.

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 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 et aux Évaluations 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.

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.

​Aperçu

​Prérequis

​Traçage de base

​Tracer une fonction

​Utiliser les Model pour l’expérimentation

Aperçu

Prérequis

Traçage de base

Tracer une fonction

Utiliser les `Model` pour l’expérimentation