benchllm

?️‍♂️ BancoLLM ?️‍♀️

? Integração contínua para aplicativos com tecnologia LLM ???

BenchLLM é uma biblioteca de código aberto baseada em Python que agiliza o teste de Large Language Models (LLMs) e aplicativos baseados em IA. Ele mede a precisão do seu modelo, agentes ou cadeias, validando respostas em qualquer número de testes por meio de LLMs.

BenchLLM é usado ativamente na V7 para melhorar nossos aplicativos LLM e agora é de código aberto sob licença MIT para compartilhar com a comunidade em geral

Obtenha ajuda no Discord ou envie um tweet para nós

---

Use o BenchLLM para:

• Teste as respostas do seu LLM em qualquer número de solicitações.
• Integração contínua para cadeias como Langchain, agentes como AutoGPT ou modelos LLM como Llama ou GPT-4.
• Elimine cadeias instáveis ​​e crie confiança em seu código.
• Identifique respostas imprecisas e alucinações em seu aplicativo em todas as versões.

---

️ NOTA: O BenchLLM está no estágio inicial de desenvolvimento e estará sujeito a mudanças rápidas.

Para relatórios de bugs, solicitações de recursos ou contribuições, abra um problema ou envie uma solicitação pull (PR) em nossa página GitHub.

? Metodologia de teste BenchLLM

BenchLLM implementa uma metodologia distinta de duas etapas para validar seus modelos de aprendizado de máquina:

1. Teste : este estágio envolve executar seu código em qualquer número de respostas esperadas e capturar as previsões produzidas por seu modelo sem julgamento ou comparação imediata.

2. Avaliação : As previsões registradas são comparadas com o resultado esperado usando LLMs para verificar a similaridade factual (ou opcionalmente manualmente). São gerados relatórios de comparação detalhados, incluindo status de aprovação/reprovação e outras métricas.

Essa separação metódica oferece uma visão abrangente do desempenho do seu modelo e permite melhor controle e refinamento de cada etapa.

Instalar

Para instalar o BenchLLM usamos pip

 pip install benchllm

Uso

Comece importando a biblioteca e use o decorador @benchllm.test para marcar a função que deseja testar:

 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 seguir, prepare seus testes. Estes são arquivos YAML/JSON estruturados da seguinte forma:

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

No exemplo acima, a input é a consulta ou instrução que seu modelo irá processar e expected contém as possíveis respostas que seu modelo deve retornar. É importante observar que input pode ser um str simples ou um dicionário aninhado mais complexo; BenchLLM extrairá o tipo do argumento input no código Python e carregará o campo input do arquivo YAML de acordo.

Por padrão, o BenchLLM usa o modelo GPT-3 da OpenAI para o avaliador semantic . Isso requer a configuração da variável de ambiente OPENAI_API_KEY . Se você não quiser usar esse avaliador padrão, poderá especificar um alternativo (discutido em mais detalhes abaixo):

 export OPENAI_API_KEY= ' your-api-key '

Substitua 'your-api-key' pela sua chave de API OpenAI real.

Para iniciar o teste, use o comando bench run :

$ bench run

Por padrão, o comando bench run procura arquivos Python que implementam o decorador @test no diretório atual. Para direcionar um arquivo ou pasta específico, especifique-o diretamente:

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

O parâmetro --retry-count permite que o BenchLLM execute um teste várias vezes, útil para modelos que podem ter variabilidade em seus resultados:

$ bench run --retry-count 5

BenchLLM oferece vários métodos de avaliação para determinar se a previsão corresponde aos valores esperados do caso de teste. Você pode usar o parâmetro --evaluator para especificar o método de avaliação:

Existem várias maneiras de avaliar se a previsão das funções de teste corresponde aos valores esperados dos casos de teste. Por padrão, GPT-3 é usado para comparar a saída. Você pode usar --evaluator para usar um método diferente

• semantic , verifica a similaridade semântica usando modelos de linguagem como GPT-3, GPT-3.5 ou GPT-4 (parâmetro --model ). Observe que, para este avaliador, você precisa definir a variável de ambiente OPENAI_API_KEY .
• embedding , usa a distância do cosseno entre os vetores incorporados. Observe que, para este avaliador, você precisa definir a variável de ambiente OPENAI_API_KEY .
• string-match , verifica se as strings são correspondentes (sem distinção entre maiúsculas e minúsculas)
• interactive , o usuário aceita manualmente ou falha nos testes no terminal
• web , usa pywebio para uma interface web local simples

Os avaliadores não interativos também apoiam --workers N para executar as avaliações em paralelo

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

Para acelerar o processo de avaliação, o BenchLLM utiliza um cache. Se um par (previsão, esperado) foi avaliado no passado e um cache foi usado, a saída da avaliação será salva para avaliações futuras. Existem vários tipos de caches:

• memory , armazena em cache apenas os valores de saída durante a execução atual. Isto é particularmente útil ao executar com --retry-count N
• file , armazena o cache no final da execução como um arquivo JSON em output/cache.json. Este é o comportamento padrão.
• none , não usa nenhum cache.

$ bench run examples --cache memory

Ao trabalhar no desenvolvimento de cadeias ou no treinamento de modelos de agentes, pode haver casos em que esses modelos precisem interagir com funções externas – por exemplo, consultar uma previsão do tempo ou executar uma consulta SQL. Nesses cenários, o BenchLLM facilita a simulação dessas funções. Isso ajuda a tornar seus testes mais previsíveis e permite a descoberta de chamadas de função 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

No exemplo acima, a função get_n_day_weather_forecast no módulo forecast é simulada. Em outras palavras, toda vez que esta função for invocada, o modelo receberá "It's sunny in London" . BenchLLM também fornece avisos se a função for invocada com valores de argumento diferentes de get_n_day_weather_forecast(location=London, num_days=1) . Observe que o fornecimento desses parâmetros de argumento é opcional.

? Avaliação

Embora o bench run execute cada função de teste e avalie sua saída, muitas vezes pode ser benéfico separá-las em duas etapas. Por exemplo, se você quiser que uma pessoa faça a avaliação manualmente ou se quiser tentar vários métodos de avaliação na mesma função.

$ bench run --no-eval

Isso irá gerar arquivos json em output/latest/predictions Mais tarde, você poderá avaliá-los com

$ bench eval output/latest/predictions

? API

Para um controle mais detalhado, BenchLLM fornece uma API. Não é necessário adicionar testes YML/JSON para poder avaliar seu modelo. Em vez disso, você pode:

• Instanciar objetos Test
• Use um objeto Tester para gerar previsões
• Use um objeto Evaluator para avaliar seu 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 )

Se quiser incorporar o armazenamento em cache e executar vários trabalhos de avaliação paralela, você poderá modificar seu avaliador da seguinte maneira:

 from benchllm . cache import FileCache

...

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

Neste exemplo, FileCache é usado para habilitar o cache, e o parâmetro workers de StringMatchEvaluator é definido como 2 para permitir avaliações paralelas. Os resultados do cache são salvos em um arquivo especificado por Path("path/to/cache.json") .

☕️ Comandos

• bench add : adiciona um novo teste a um conjunto.
• bench tests : liste todos os testes em um conjunto.
• bench run : executa todos os conjuntos de testes de destino.
• bench eval : Executa a avaliação de uma execução de teste existente.

? Contribuir

BenchLLM foi desenvolvido para Python 3.10, embora também possa funcionar com outras versões do Python. Recomendamos usar um ambiente Python 3.10 e pip >= 23. Você pode usar conda ou qualquer outro gerenciador de ambiente para configurar o ambiente:

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

Para executar todos os exemplos primeiro instale as dependências extras dos exemplos

$ pip install -e " .[examples] "

Etapas de contribuição:

1. Bifurque o repositório.
2. Crie um novo branch para suas alterações.
3. Faça suas alterações.
4. Teste suas alterações.
5. Envie uma solicitação pull.

Aderimos ao guia de estilo PEP8. Por favor, siga este guia ao contribuir.

Se precisar de suporte, sinta-se à vontade para abrir um problema em nossa página GitHub.