benchllm

?️‍♂️ BenchLLM ?️‍♀️

? Intégration continue pour les applications alimentées par LLM ???

BenchLLM est une bibliothèque open source basée sur Python qui rationalise les tests des grands modèles linguistiques (LLM) et des applications basées sur l'IA. Il mesure la précision de votre modèle, de vos agents ou de vos chaînes en validant les réponses à un nombre quelconque de tests via des LLM.

BenchLLM est activement utilisé dans la V7 pour améliorer nos applications LLM et est désormais Open Source sous licence MIT pour être partagé avec la communauté au sens large.

Obtenez de l'aide sur Discord ou tweetez-nous

---

Utilisez BenchLLM pour :

• Testez les réponses de votre LLM à travers un nombre illimité d'invites.
• Intégration continue pour des chaînes comme Langchain, des agents comme AutoGPT ou des modèles LLM comme Llama ou GPT-4.
• Éliminez les chaînes floconneuses et créez de la confiance dans votre code.
• Repérez les réponses inexactes et les hallucinations dans votre application à chaque version.

---

️ REMARQUE : BenchLLM en est à ses premiers stades de développement et sera sujet à des changements rapides.

Pour les rapports de bogues, les demandes de fonctionnalités ou les contributions, veuillez ouvrir un problème ou soumettre une pull request (PR) sur notre page GitHub.

? Méthodologie de test BenchLLM

BenchLLM met en œuvre une méthodologie distincte en deux étapes pour valider vos modèles d'apprentissage automatique :

1. Tests : cette étape consiste à exécuter votre code sur un nombre quelconque de réponses attendues et à capturer les prédictions produites par votre modèle sans jugement ni comparaison immédiate.

2. Évaluation : les prédictions enregistrées sont comparées au résultat attendu à l'aide de LLM pour vérifier la similarité factuelle (ou éventuellement manuellement). Des rapports de comparaison détaillés, comprenant le statut réussite/échec et d'autres mesures, sont générés.

Cette séparation méthodique offre une vue complète des performances de votre modèle et permet un meilleur contrôle et un meilleur affinement de chaque étape.

Installer

Pour installer BenchLLM, nous utilisons pip

 pip install benchllm

Usage

Commencez par importer la bibliothèque et utilisez le décorateur @benchllm.test pour marquer la fonction que vous souhaitez tester :

 import benchllm

# Your custom model implementation
def run_my_model ( input ):
    # Your model's logic goes here.
    return some_result

@ benchllm . test ( suite = "/path/to/test/suite" ) # If the tests are in the same directory, just use @benchllm.test.
def invoke_model ( input : str ):
    return run_my_model ( input )

Ensuite, préparez vos tests. Il s'agit de fichiers YAML/JSON structurés comme suit :

 input : What's 1+1? Be very terse, only numeric output
expected :
  - 2
  - 2.0

Dans l'exemple ci-dessus, l' input est la requête ou l'instruction que votre modèle va traiter, et expected contient les réponses potentielles que votre modèle doit renvoyer. Il est important de noter que input peut être une simple str ou un dictionnaire imbriqué plus complexe ; BenchLLM extraira le type de l'argument input dans le code Python et chargera le champ input du fichier YAML en conséquence.

Par défaut, BenchLLM utilise le modèle GPT-3 d'OpenAI pour l'évaluateur semantic . Cela nécessite la définition de la variable d'environnement OPENAI_API_KEY . Si vous ne souhaitez pas utiliser cet évaluateur par défaut, vous pouvez en spécifier un autre (discuté plus en détail ci-dessous) :

 export OPENAI_API_KEY= ' your-api-key '

Remplacez « votre clé API » par votre clé API OpenAI réelle.

Pour lancer les tests, utilisez la commande bench run :

$ bench run

Par défaut, la commande bench run recherche les fichiers Python implémentant le décorateur @test dans le répertoire courant. Pour cibler un fichier ou un dossier spécifique, spécifiez-le directement :

$ bench run path/to/my/file.py or/path/to/folder/with/files

Le paramètre --retry-count permet à BenchLLM d'exécuter un test plusieurs fois, ce qui est utile pour les modèles dont les sorties peuvent varier :

$ bench run --retry-count 5

BenchLLM propose plusieurs méthodes d'évaluation pour déterminer si la prédiction correspond aux valeurs attendues du scénario de test. Vous pouvez utiliser le paramètre --evaluator pour spécifier la méthode d'évaluation :

Il existe plusieurs façons d'évaluer si la prédiction des fonctions de test correspond aux valeurs attendues des cas de test. Par défaut, GPT-3 est utilisé pour comparer la sortie. Vous pouvez utiliser --evaluator pour utiliser une méthode différente

• semantic , vérifie la similarité sémantique à l'aide de modèles de langage tels que GPT-3, GPT-3.5 ou GPT-4 (paramètre --model ). Veuillez noter que pour cet évaluateur, vous devez définir la variable d'environnement OPENAI_API_KEY .
• embedding , utilise la distance cosinusoïdale entre les vecteurs intégrés. Veuillez noter que pour cet évaluateur, vous devez définir la variable d'environnement OPENAI_API_KEY .
• string-match , vérifie si les chaînes correspondent (insensible à la casse)
• interactive , l'utilisateur accepte ou échoue manuellement les tests dans le terminal
• web , utilise pywebio pour une interface Web locale simple

Les évaluateurs non interactifs prennent également en charge --workers N pour exécuter les évaluations en parallèle

$ bench run --evaluator string-match --workers 5

Pour accélérer le processus d'évaluation, BenchLLM utilise un cache. Si une paire (prédiction, attendue) a été évaluée dans le passé et qu'un cache a été utilisé, le résultat de l'évaluation sera enregistré pour les évaluations futures. Il existe plusieurs types de caches :

• memory , met en cache uniquement les valeurs de sortie pendant l'exécution en cours. Ceci est particulièrement utile lors de l'exécution avec --retry-count N
• file , stocke le cache à la fin de l'exécution en tant que fichier JSON dans output/cache.json. Il s'agit du comportement par défaut.
• none , n'utilise aucun cache.

$ bench run examples --cache memory

Lorsque vous travaillez sur le développement de chaînes ou de modèles d'agents de formation, il peut arriver que ces modèles doivent interagir avec des fonctions externes, par exemple pour interroger des prévisions météorologiques ou exécuter une requête SQL. Dans de tels scénarios, BenchLLM facilite la possibilité de se moquer de ces fonctions. Cela vous aide à rendre vos tests plus prévisibles et permet la découverte d'appels de fonction inattendus.

 input : I live in London, can I expect rain today?
expected : ["no"]
calls :
  - name : forecast.get_n_day_weather_forecast
    returns : It's sunny in London.
    arguments :
      location : London
      num_days : 1

Dans l'exemple ci-dessus, la fonction get_n_day_weather_forecast dans le module forecast est simulée. En d'autres termes, chaque fois que cette fonction est invoquée, le modèle recevra "It's sunny in London" . BenchLLM fournit également des avertissements si la fonction est invoquée avec des valeurs d'argument différentes de get_n_day_weather_forecast(location=London, num_days=1) . Veuillez noter que la fourniture de ces paramètres d'argument est facultative.

? Évaluer

Tandis que l'exécution sur banc exécute chaque fonction de test et évalue ensuite leur sortie, il peut souvent être avantageux de les séparer en deux étapes. Par exemple, si vous souhaitez qu'une personne effectue manuellement l'évaluation ou si vous souhaitez essayer plusieurs méthodes d'évaluation sur la même fonction.

$ bench run --no-eval

Cela générera des fichiers json dans output/latest/predictions Ensuite, vous pourrez les évaluer avec

$ bench eval output/latest/predictions

? API

Pour un contrôle plus détaillé, BenchLLM fournit une API. Vous n'êtes pas obligé d'ajouter des tests YML/JSON pour pouvoir évaluer votre modèle. Vous pouvez à la place :

• Instancier des objets Test
• Utiliser un objet Tester pour générer des prédictions
• Utilisez un objet Evaluator pour évaluer votre modèle

 from benchllm import StringMatchEvaluator , Test , Tester

# Instantiate your Test objects
tests = [
    Test ( input = "What's 1+1?" , expected = [ "2" , "It's 2" ]),
    Test ( input = "First rule of fight club?" , expected = [ "Do not talk about fight club" ]),
]

# Use a Tester object to generate predictions using any test functions
tester = Tester ( my_test_function )
tester . add_tests ( tests )
predictions = tester . run ()

# Use an Evaluator object to evaluate your model
evaluator = StringMatchEvaluator ()
evaluator . load ( predictions )
results = evaluator . run ()

print ( results )

Si vous souhaitez intégrer la mise en cache et exécuter plusieurs tâches d'évaluation parallèles, vous pouvez modifier votre évaluateur comme suit :

 from benchllm . cache import FileCache

...

evaluator = FileCache ( StringMatchEvaluator ( workers = 2 ), Path ( "path/to/cache.json" ))
evaluator . load ( predictions )
results = evaluator . run ()

Dans cet exemple, FileCache est utilisé pour activer la mise en cache et le paramètre workers de StringMatchEvaluator est défini sur 2 pour permettre des évaluations parallèles. Les résultats du cache sont enregistrés dans un fichier spécifié par Path("path/to/cache.json") .

☕️ Commandes

• bench add : Ajouter un nouveau test à une suite.
• bench tests : répertorie tous les tests d'une suite.
• bench run : exécutez toutes les suites de tests ou ciblez-les.
• bench eval : exécute l’évaluation d’une exécution de test existante.

? Contribuer

BenchLLM est développé pour Python 3.10, bien qu'il puisse également fonctionner avec d'autres versions de Python. Nous vous recommandons d'utiliser un environnement Python 3.10 et pip >= 23. Vous pouvez utiliser conda ou tout autre gestionnaire d'environnement pour configurer l'environnement :

$ conda create --name benchllm python=3.10
$ conda activate benchllm
$ pip install -e " .[dev] "

Pour exécuter tous les exemples, installez d'abord les dépendances supplémentaires des exemples

$ pip install -e " .[examples] "

Étapes de contribution :

1. Forkez le référentiel.
2. Créez une nouvelle branche pour vos modifications.
3. Apportez vos modifications.
4. Testez vos modifications.
5. Soumettez une pull request.

Nous adhérons au guide de style PEP8. Veuillez suivre ce guide lorsque vous contribuez.

Si vous avez besoin d'aide, n'hésitez pas à ouvrir un ticket sur notre page GitHub.