Groq - Weights & Biases Documentation

Vous voulez tester les modèles Groq sur Weave sans rien configurer ? Essayez le LLM Playground.

Groq est une entreprise d’infrastructure IA qui fournit une inférence IA rapide. Le LPU Inference Engine de Groq est une plateforme matérielle et logicielle conçue pour la vitesse de calcul, la qualité et l’efficacité énergétique. Weave suit et journalise automatiquement les appels de complétion de chat de Groq. Cette page explique comment utiliser Weave pour tracer les appels de complétion de chat de Groq, encapsuler vos propres fonctions en tant qu’ops Weave et organiser vos expériences à l’aide d’objets Model.

Tracing

Il est important de stocker les traces des applications de modèles de langage dans un emplacement centralisé, aussi bien pendant le développement qu’en production. Ces traces peuvent vous aider à déboguer votre application et servir de jeu de données pour l’améliorer. Weave capture automatiquement les traces pour Groq. Pour commencer le suivi, appelez weave.init(project_name="<your-wandb-project-name>") et utilisez la bibliothèque normalement. Remplacez les valeurs entre <> par les vôtres.

import os
import weave
from groq import Groq

weave.init(project_name="groq-project")

client = Groq(
    api_key=os.environ.get("GROQ_API_KEY"),
)
chat_completion = client.chat.completions.create(
    messages=[
        {
            "role": "user",
            "content": "Explain the importance of fast language models",
        }
    ],
    model="llama3-8b-8192",
)


Weave suit et journalise désormais tous les appels LLM effectués via la bibliothèque Groq. Vous pouvez consulter les traces dans l’interface web de Weave.

Suivez vos propres ops

Décorez une fonction avec @weave.op pour capturer les entrées, les sorties et la logique de l’application afin que vous puissiez déboguer la façon dont les données circulent dans votre application. Vous pouvez imbriquer des ops en profondeur et créer une arborescence de fonctions que vous souhaitez suivre. Cela gère également automatiquement les versions du code pendant que vous expérimentez, afin de capturer des détails ad hoc qui n’ont pas été commités dans git. Créez une fonction décorée avec @weave.op. Dans l’exemple suivant, la fonction recommend_places_to_visit, décorée avec @weave.op, recommande des lieux à visiter dans une ville.

import os
import weave
from groq import Groq


weave.init(project_name="groq-test")

client = Groq(
    api_key=os.environ.get("GROQ_API_KEY"),
)

@weave.op()
def recommend_places_to_visit(city: str, model: str="llama3-8b-8192"):
    chat_completion = client.chat.completions.create(
        messages=[
            {
                "role": "system",
                "content": "You are a helpful assistant meant to suggest places to visit in a city",
            },
            {
                "role": "user",
                "content": city,
            }
        ],
        model="llama3-8b-8192",
    )
    return chat_completion.choices[0].message.content


recommend_places_to_visit("New York")
recommend_places_to_visit("Paris")
recommend_places_to_visit("Kolkata")


Décorez la fonction `recommend_places_to_visit` avec `@weave.op` pour tracer ses entrées, ses sorties et tous les appels LM internes effectués dans la fonction.

Créez un `Model` pour faciliter l’expérimentation

Il est difficile d’organiser l’expérimentation lorsqu’il y a de nombreux éléments en jeu. En utilisant la classe Model, vous pouvez capturer et organiser les détails expérimentaux de votre application, comme le prompt système ou le modèle que vous utilisez. Cela facilite l’organisation et la comparaison des différentes itérations de votre application. En plus de la gestion des versions du code et de la capture des entrées et des sorties, les Models capturent des paramètres structurés qui contrôlent le comportement de votre application, vous aidant à trouver les paramètres les plus efficaces. Vous pouvez également utiliser des Weave Models avec serve et des Evaluations. Dans l’exemple suivant, vous pouvez expérimenter avec GroqCityVisitRecommender. À chaque modification de l’un de ces éléments, vous obtenez une nouvelle version de GroqCityVisitRecommender.

import os
from groq import Groq
import weave


class GroqCityVisitRecommender(weave.Model):
    model: str
    groq_client: Groq

    @weave.op()
    def predict(self, city: str) -> str:
        system_message = {
            "role": "system",
            "content": """
You are a helpful assistant meant to suggest places to visit in a city
""",
        }
        user_message = {"role": "user", "content": city}
        chat_completion = self.groq_client.chat.completions.create(
            messages=[system_message, user_message],
            model=self.model,
        )
        return chat_completion.choices[0].message.content


weave.init(project_name="groq-test")
city_recommender = GroqCityVisitRecommender(
    model="llama3-8b-8192", groq_client=Groq(api_key=os.environ.get("GROQ_API_KEY"))
)
print(city_recommender.predict("New York"))
print(city_recommender.predict("San Francisco"))
print(city_recommender.predict("Los Angeles"))


Tracez et gérez les versions de vos appels à l’aide d’un `Model`.

Servir un Weave Model

Une fois que vous disposez d’un Model versionné, vous pouvez le déployer en tant que service pour des tests ou des applications en aval. À partir d’une référence Weave vers n’importe quel objet weave.Model, vous pouvez lancer un serveur FastAPI et le Serve.


Vous pouvez trouver la référence Weave de n’importe quel `weave.Model` en ouvrant le modèle, puis en la copiant depuis l’UI.

Servez votre modèle avec la commande suivante dans le terminal :

weave serve weave://your_entity/project-name/YourModel:<hash>

​Tracing

​Suivez vos propres ops

​Créez un Model pour faciliter l’expérimentation

​Servir un Weave Model

Tracing

Suivez vos propres ops

Créez un `Model` pour faciliter l’expérimentation

Servir un Weave Model