BenchLLM

BenchLLM : L'outil ultime d'évaluation des LLM

Qu'est-ce que BenchLLM ? BenchLLM est un framework open-source conçu pour évaluer et tester les applications alimentées par des modèles de langage de grande taille (LLM). Il permet aux ingénieurs en AI de créer des suites de tests, de générer des rapports de qualité et de surveiller les performances des modèles. Il prend en charge les stratégies d'évaluation automatisées, interactives et personnalisées, offrant flexibilité et puissance sans compromettre la prévisibilité des résultats.

Principales caractéristiques :

• API flexible : BenchLLM prend en charge OpenAI, Langchain et toute autre API prête à l'emploi.
• CLI puissant : Exécutez et évaluez des modèles avec de simples commandes CLI, idéales pour les pipelines CI/CD.
• Évaluation facile : Définissez les tests de manière intuitive au format JSON ou YAML.
• Tests organisés : Organisez facilement les tests en suites versionnables.
• Automatisation : Automatisez les évaluations dans les pipelines CI/CD.
• Rapports : Générez et partagez des rapports d'évaluation.
• Surveillance des performances : Détectez les régressions en production en surveillant les performances du modèle.

Comment fonctionne BenchLLM ?

BenchLLM permet aux ingénieurs en AI d'évaluer efficacement leur code et leurs LLM grâce à plusieurs étapes :

1. Instancier des objets de test : Définissez des tests en créant des objets Test avec des entrées et des sorties attendues.
2. Générer des prédictions : Utilisez un objet Tester pour exécuter les tests et générer des prédictions à partir de votre modèle.
3. Évaluer les modèles : Utilisez un objet Evaluator, tel que SemanticEvaluator, pour évaluer les prédictions du modèle.

Voici un exemple de base :

from benchllm import SemanticEvaluator, Test, Tester
from langchain.agents import AgentType, initialize_agent
from langchain.llms import OpenAI

## Gardez votre code organisé comme vous le souhaitez
def run_agent(input: str):
    llm=OpenAI(temperature=0)
    agent = initialize_agent(
        load_tools(["serpapi", "llm-math"], llm=llm),
        llm=llm,
        agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION
    )
    return agent(input)["output"]

## Instancier vos objets de test
tests = [
    Test(
        input="Quand V7 a-t-elle été fondée ? Divisez-la par 2",
        expected=["1009", "Cela ferait 2018 / 2 = 1009"]
    )
]

## Utilisez un objet Tester pour générer des prédictions
tester = Tester(run_agent)
tester.add_tests(tests)
predictions = tester.run()

## Utilisez un objet Evaluator pour évaluer votre modèle
evaluator = SemanticEvaluator(model="gpt-3")
evaluator.load(predictions)
evaluator.run()

CLI puissant pour l'intégration CI/CD

BenchLLM dispose d'une interface de ligne de commande (CLI) puissante qui permet une intégration transparente dans les pipelines CI/CD. Vous pouvez exécuter des tests et évaluer des modèles à l'aide de simples commandes CLI, ce qui facilite la surveillance des performances des modèles et la détection des régressions en production.

API flexible pour les évaluations personnalisées

L'API flexible de BenchLLM prend en charge OpenAI, Langchain et pratiquement toute autre API. Cela vous permet de tester votre code à la volée et d'utiliser plusieurs stratégies d'évaluation, fournissant des rapports perspicaces adaptés à vos besoins spécifiques.

Comment utiliser BenchLLM ?

Pour commencer avec BenchLLM, suivez ces étapes :

1. Télécharger et installer : Téléchargez et installez BenchLLM.
2. Définir les tests : Définissez vos tests au format JSON ou YAML.
3. Exécuter les tests : Utilisez la CLI ou l'API pour exécuter vos tests.
4. Générer des rapports : Générez des rapports d'évaluation et partagez-les avec votre équipe.

Voici un exemple de la façon de définir un test à l'aide du décorateur @benchllm.test :

import benchllm
from benchllm.input_types import ChatInput
import openai

def chat(messages: ChatInput):
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=messages
    )
    return response.choices[0].message.content.strip()

@benchllm.test(suite=".")
def run(input: ChatInput):
    return chat(input)

À qui s'adresse BenchLLM ?

BenchLLM est idéal pour :

• Les ingénieurs en AI qui souhaitent garantir la qualité et la fiabilité de leurs applications alimentées par des LLM.
• Les développeurs à la recherche d'un outil flexible et puissant pour évaluer leurs modèles.
• Les équipes qui ont besoin de surveiller les performances des modèles et de détecter les régressions en production.

Pourquoi choisir BenchLLM ?

• Open-Source : Bénéficiez d'un outil transparent et axé sur la communauté.
• Flexibilité : Prend en charge diverses API et stratégies d'évaluation.
• Intégration : S'intègre de manière transparente dans les pipelines CI/CD.
• Rapports complets : Fournit des rapports perspicaces pour suivre les performances des modèles.

BenchLLM est construit et maintenu avec ♥ par V7, une équipe d'ingénieurs en AI passionnés par la création de produits d'AI. L'outil vise à combler le fossé entre la puissance et la flexibilité de l'AI et la nécessité d'obtenir des résultats prévisibles.

Partagez vos commentaires, vos idées et vos contributions avec Simon Edwardsson ou Andrea Azzini pour aider à améliorer BenchLLM et à en faire le meilleur outil d'évaluation de LLM pour les ingénieurs en AI.

En choisissant BenchLLM, vous vous assurez que vos applications LLM répondent aux normes de qualité et de fiabilité les plus élevées. Téléchargez BenchLLM dès aujourd'hui et commencez à évaluer vos modèles en toute confiance !