benchllm

?️‍♂️ BancoLLM ?️‍♀️

? ¿Integración continua para aplicaciones impulsadas por LLM?

BenchLLM es una biblioteca de código abierto basada en Python que agiliza las pruebas de modelos de lenguajes grandes (LLM) y aplicaciones impulsadas por IA. Mide la precisión de su modelo, agentes o cadenas validando las respuestas en cualquier cantidad de pruebas a través de LLM.

BenchLLM se utiliza activamente en V7 para mejorar nuestras aplicaciones LLM y ahora es de código abierto bajo licencia MIT para compartir con la comunidad en general.

Obtén ayuda en Discord o envíanos un tweet

---

Utilice BenchLLM para:

• Pruebe las respuestas de su LLM en cualquier número de indicaciones.
• Integración continua para cadenas como Langchain, agentes como AutoGPT o modelos LLM como Llama o GPT-4.
• Elimine las cadenas inestables y genere confianza en su código.
• Detecte respuestas inexactas y alucinaciones en su aplicación en cada versión.

---

️ NOTA: BenchLLM se encuentra en la etapa inicial de desarrollo y estará sujeto a cambios rápidos.

Para informes de errores, solicitudes de funciones o contribuciones, abra una incidencia o envíe una solicitud de extracción (PR) en nuestra página de GitHub.

? Metodología de prueba BenchLLM

BenchLLM implementa una metodología distinta de dos pasos para validar sus modelos de aprendizaje automático:

1. Prueba : esta etapa implica ejecutar su código contra cualquier número de respuestas esperadas y capturar las predicciones producidas por su modelo sin juicio ni comparación inmediata.

2. Evaluación : las predicciones registradas se comparan con el resultado esperado utilizando LLM para verificar la similitud fáctica (u opcionalmente manualmente). Se generan informes de comparación detallados, que incluyen el estado de aprobación/rechazo y otras métricas.

Esta separación metódica ofrece una visión integral del rendimiento de su modelo y permite un mejor control y refinamiento de cada paso.

Instalar

Para instalar BenchLLM usamos pip

 pip install benchllm

Uso

Comience importando la biblioteca y use el decorador @benchllm.test para marcar la función que desea probar:

 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 )

A continuación, prepare sus pruebas. Estos son archivos YAML/JSON estructurados de la siguiente manera:

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

En el ejemplo anterior, la input es la consulta o instrucción que procesará su modelo y expected contiene las posibles respuestas que su modelo debería devolver. Es importante tener en cuenta que input puede ser una str simple o un diccionario anidado más complejo; BenchLLM extraerá el tipo de argumento input en el código Python y cargará el campo input del archivo YAML en consecuencia.

De forma predeterminada, BenchLLM utiliza el modelo GPT-3 de OpenAI para el evaluador semantic . Esto requiere configurar la variable de entorno OPENAI_API_KEY . Si no desea utilizar este evaluador predeterminado, puede especificar uno alternativo (que se analiza con más detalle a continuación):

 export OPENAI_API_KEY= ' your-api-key '

Reemplace 'your-api-key' con su clave API OpenAI real.

Para iniciar la prueba, utilice el comando bench run :

$ bench run

De forma predeterminada, el comando de ejecución en banco busca archivos Python que implementen el decorador @test en el directorio actual. Para apuntar a un archivo o carpeta específica, especifíquelo directamente:

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

El parámetro --retry-count permite a BenchLLM ejecutar una prueba varias veces, lo que resulta útil para modelos que pueden tener variabilidad en sus resultados:

$ bench run --retry-count 5

BenchLLM ofrece múltiples métodos de evaluación para determinar si la predicción coincide con los valores esperados del caso de prueba. Puede utilizar el parámetro --evaluator para especificar el método de evaluación:

Hay varias formas de evaluar si la predicción de las funciones de prueba coincide con los valores esperados de los casos de prueba. De forma predeterminada, se utiliza GPT-3 para comparar la salida. Puedes usar --evaluator para usar un método diferente

• semantic , comprueba la similitud semántica utilizando modelos de lenguaje como GPT-3, GPT-3.5 o GPT-4 (parámetro --model ). Tenga en cuenta que para este evaluador, debe configurar la variable de entorno OPENAI_API_KEY .
• embedding , utiliza la distancia coseno entre vectores incrustados. Tenga en cuenta que para este evaluador, debe configurar la variable de entorno OPENAI_API_KEY .
• string-match , comprueba si las cadenas coinciden (no distingue entre mayúsculas y minúsculas)
• interactive , el usuario acepta o falla manualmente las pruebas en el terminal.
• web , utiliza pywebio para una interfaz web local simple

Los evaluadores no interactivos también apoyan --workers N para ejecutar las evaluaciones en paralelo.

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

Para acelerar el proceso de evaluación, BenchLLM utiliza un caché. Si un par (predicción, esperado) se evaluó en el pasado y se utilizó un caché, el resultado de la evaluación se guardará para evaluaciones futuras. Hay varios tipos de cachés:

• memory , solo almacena en caché los valores de salida durante la ejecución actual. Esto es particularmente útil cuando se ejecuta con --retry-count N
• file , almacena el caché al final de la ejecución como un archivo JSON en output/cache.json. Este es el comportamiento predeterminado.
• none , no utiliza ningún caché.

$ bench run examples --cache memory

Cuando se trabaja en el desarrollo de cadenas o en la capacitación de modelos de agentes, puede haber casos en los que estos modelos necesiten interactuar con funciones externas, por ejemplo, consultar un pronóstico del tiempo o ejecutar una consulta SQL. En tales escenarios, BenchLLM facilita la posibilidad de burlarse de estas funciones. Esto le ayuda a hacer que sus pruebas sean más predecibles y permite descubrir llamadas a funciones inesperadas.

 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

En el ejemplo anterior, se simula la función get_n_day_weather_forecast en el módulo forecast . En otras palabras, cada vez que se invoque esta función, el modelo recibirá "It's sunny in London" . BenchLLM también proporciona advertencias si la función se invoca con valores de argumento diferentes de get_n_day_weather_forecast(location=London, num_days=1) . Tenga en cuenta que la provisión de estos parámetros de argumento es opcional.

? evaluar

Si bien la ejecución en banco ejecuta cada función de prueba y luego evalúa su resultado, a menudo puede resultar beneficioso separarlas en dos pasos. Por ejemplo, si desea que una persona realice la evaluación manualmente o si desea probar varios métodos de evaluación en la misma función.

$ bench run --no-eval

Esto generará archivos json en output/latest/predictions Luego, podrá evaluarlos con

$ bench eval output/latest/predictions

? API

Para un control más detallado, BenchLLM proporciona una API. No es necesario que agregue pruebas YML/JSON para poder evaluar su modelo. En su lugar puedes:

• Crear instancias de objetos Test
• Utilice un objeto Tester para generar predicciones
• Utilice un objeto Evaluator para evaluar su modelo

 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 desea incorporar el almacenamiento en caché y ejecutar múltiples trabajos de evaluación paralelos, puede modificar su evaluador de la siguiente manera:

 from benchllm . cache import FileCache

...

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

En este ejemplo, FileCache se utiliza para habilitar el almacenamiento en caché y el parámetro de workers de StringMatchEvaluator se establece en 2 para permitir evaluaciones paralelas. Los resultados del caché se guardan en un archivo especificado por Path("path/to/cache.json") .

☕️ Comandos

• bench add : agregue una nueva prueba a una suite.
• bench tests : enumera todas las pruebas de una suite.
• bench run : ejecute todos los conjuntos de pruebas o los conjuntos de pruebas de destino.
• bench eval : ejecuta la evaluación de una ejecución de prueba existente.

? Contribuir

BenchLLM está desarrollado para Python 3.10, aunque también puede funcionar con otras versiones de Python. Recomendamos usar un entorno Python 3.10 y pip >= 23. Puede usar conda o cualquier otro administrador de entorno para configurar el entorno:

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

Para ejecutar todos los ejemplos, primero instale las dependencias adicionales de los ejemplos.

$ pip install -e " .[examples] "

Pasos de contribución:

1. Bifurca el repositorio.
2. Cree una nueva rama para sus cambios.
3. Haz tus cambios.
4. Pruebe sus cambios.
5. Envíe una solicitud de extracción.

Nos adherimos a la guía de estilo PEP8. Siga esta guía cuando contribuya.

Si necesita ayuda, no dude en abrir un problema en nuestra página de GitHub.