Groq - CoreWeave Docs

Vous souhaitez tester les modèles Groq dans Weave sans aucune configuration ? Essayez le LLM Playground.

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

Traçage

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 à suivre vos appels, appelez weave.init(project_name="<your-wandb-project-name>"), puis 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.

Suivre vos propres ops

Encapsulez une fonction avec @weave.op pour capturer les entrées, les sorties et la logique de votre application, afin de déboguer la circulation des données en son sein. Vous pouvez imbriquer des ops sur plusieurs niveaux et construire une arborescence des fonctions que vous souhaitez suivre. Le code est également versionné automatiquement au fil de vos expériences, ce qui permet de capturer des détails ponctuels qui n’ont pas encore é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 est encapsulée avec @weave.op et 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 de LM internes effectués au sein de la fonction.

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

Il est difficile d’organiser ses expériences lorsque de nombreux éléments évoluent en même temps. La classe Model vous permet de capturer et d’organiser les détails expérimentaux de votre application, comme votre prompt système ou le modèle que vous utilisez. Vous pouvez ainsi organiser et comparer plus facilement les différentes itérations de votre application. En plus de gérer les versions du code et de capturer les entrées et les sorties, les Models capturent des paramètres structurés qui contrôlent le comportement de votre application, ce qui vous aide à trouver les paramètres les plus efficaces. Vous pouvez également utiliser les Weave Models avec serve et avec les Evaluations. Dans l’exemple suivant, vous pouvez expérimenter avec GroqCityVisitRecommender. Chaque fois que vous modifiez 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 vos appels et gérez-en les versions à 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 le tester ou l’utiliser dans 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 servir.


Pour trouver la référence Weave d’un `weave.Model`, accédez au modèle et copiez-la depuis l’interface utilisateur.

Servez votre modèle en exécutant la commande suivante dans le terminal :

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

​Traçage

​Suivre vos propres ops

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

​Servir un Weave Model

Traçage

Suivre vos propres ops

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

Servir un Weave Model