Avaliar um modelo do Amazon Bedrock para verificar a precisão do resumo de texto

Pré-requisitos

• Use uma base Python 3.10 Ambiente de kernel e uma instância do ml.m5.2xlarge Amazon Elastic Compute Cloud (Amazon EC2) antes de iniciar este tutorial.

  Para obter mais informações sobre os tipos de instância e seus casos de uso recomendados, consulte Tipos de instância disponíveis para uso com o Studio Classic.

Configuração do Amazon Bedrock

Antes de usar um modelo do Amazon Bedrock, você precisa solicitar acesso a ele.

1. Faça login no seu Conta da AWS.

   1. Se você não tiver uma AWS conta, consulte Criar uma AWS conta em Configurar o Amazon Bedrock.

2. Abra o console do Amazon Bedrock.

3. Na seção Bem-vindo ao Amazon Bedrock! que se abre, escolha Gerenciar acesso ao modelo.

4. Na seção Acesso ao modelo exibida, escolha Gerenciar acesso ao modelo.

5. Na seção Modelos básicos exibida, marque a caixa ao lado de Claude listada na subseção Anthropic de Modelos.

6. Escolha Solicitar acesso ao modelo.

7. Se sua solicitação for bem-sucedida, uma marca de seleção com Acesso concedido deverá aparecer em Status de acesso, ao lado do modelo selecionado.

8. Talvez seja necessário fazer login novamente Conta da AWS para poder acessar o modelo.

Instalar bibliotecas necessárias

1. Em seu código, instale as bibliotecas fmeval e boto3 da seguinte forma:

   !pip install fmeval
   !pip3 install boto3==1.28.65

2. Importe bibliotecas, defina um fator de paralelização e invoque um cliente Amazon Bedrock da seguinte forma:

   import boto3
   import json
   import os
   
   # Dependent on available hardware and memory
   os.environ["PARALLELIZATION_FACTOR"] = "1"
   
   # Bedrock clients for model inference
   bedrock = boto3.client(service_name='bedrock')
   bedrock_runtime = boto3.client(service_name='bedrock-runtime')

   No exemplo de código anterior, aplica-se o seguinte:

   • PARALLELIZATION_FACTOR: Um multiplicador para o número de lotes simultâneos enviados para sua instância de computação. Se o seu hardware permitir a paralelização, você pode definir esse número para multiplicar o número de invocações para seu trabalho de avaliação. Por exemplo, se você tiver 100 invocações e PARALLELIZATION_FACTOR estiver definido como 2, seu trabalho executará 200 invocações. Você pode aumentar PARALLELIZATION_FACTOR até 10 ou remover a variável totalmente. Para ler um blog sobre como o AWS Lambda usa, PARALLELIZATION_FACTOR consulte Novos controles de escalabilidade do Lambda para fontes de eventos do Kinesis e do DynamoDB.

3. Faça o download do conjunto de dados JSON Lines de amostra, sample-dataset.jsonl, em seu diretório de trabalho atual.

4. Verifique se seu ambiente contém o arquivo de entrada de amostra da seguinte forma:

   import glob
   
   # Check for the built-in dataset
   if not glob.glob("sample-dataset.jsonl"):
   print("ERROR - please make sure file exists: sample-dataset.jsonl")

Envie uma solicitação de inferência de amostra para seu modelo

1. Defina o modelo e o tipo MIME do seu prompt. Para um modelo Claude 2 da Anthropic hospedado no Amazon Bedrock, seu prompt deve ser estruturado da seguinte forma:

   import json
   model_id = 'anthropic.claude-v2'
   accept = "application/json"
   contentType = "application/json"
   # Ensure that your prompt has the correct format
   prompt_data = """Human: Who is Barack Obama?
   Assistant:
   """

   Para obter mais informações sobre como estruturar o corpo da sua solicitação, consulte Campo do corpo da solicitação de invocação do modelo. Outros modelos podem ter formatos diferentes.

2. Envie uma solicitação de amostra para seu modelo. O corpo da solicitação contém o prompt e todos os parâmetros adicionais que você deseja definir. Uma solicitação de exemplo com o max_tokens_to_sample definido como 500:

   body = json.dumps({"prompt": prompt_data, "max_tokens_to_sample": 500})
   response = bedrock_runtime.invoke_model(
   body=body, modelId=model_id, accept=accept, contentType=contentType
   )
   response_body = json.loads(response.get("body").read())
   print(response_body.get("completion"))

   No exemplo de código anterior, você pode definir os seguintes parâmetros:

   • temperature: Controla a aleatoriedade do texto gerado e aceita valores positivos. Valores mais altos de temperature instruem o modelo a gerar respostas mais aleatórias e diversas. Valores mais baixos geram respostas mais previsíveis. Intervalos para temperature ficam entre 0 e 1, com um valor padrão de 0,5.

   • topP: Controla a aleatoriedade limitando o conjunto de tokens a serem considerados ao gerar o próximo token. Valores mais altos de topP permitem um conjunto contendo um vocabulário mais amplo, e valores mais baixos restringem o conjunto de tokens a palavras mais prováveis. Intervalos para topP são de 0 até 1, com um valor padrão de 1.

   • topK: Limita as predições do modelo aos principais tokens k mais prováveis. Valores mais altos de topK permitem respostas mais inventivas. Valores mais baixos geram respostas mais coerentes. Intervalos para topK são de 0 até 500, com um valor padrão de 250.

   • max_tokens_to_sample: Limita o comprimento da resposta limitando o número de tokens retornados pelo seu modelo. Intervalos para max_tokens_to_sample são de 0 até 4096, com um valor padrão de 200.

   • stop_sequences: Especifica uma lista de sequências de caracteres que instruem seu modelo a parar de gerar uma resposta. A saída do modelo é interrompida na primeira vez que uma das sequências listadas é encontrada na saída. A resposta não contém a sequência de parada. Por exemplo, você pode usar uma sequência de retorno de carro para limitar a resposta do modelo a uma única linha. Você pode configurar até 4 sequências de paradas.

   Para obter mais informações sobre os parâmetros que você pode especificar em uma solicitação, consulte Modelos Claude da Anthropic.

Configurar FMEval

1. Carregue as bibliotecas necessárias para serem executadas da FMEval seguinte maneira:

   from fmeval.data_loaders.data_config import DataConfig
   from fmeval.model_runners.bedrock_model_runner import BedrockModelRunner
   from fmeval.constants import MIME_TYPE_JSONLINES
   from fmeval.eval_algorithms.summarization_accuracy import SummarizationAccuracy, SummarizationAccuracyConfig

2. Defina a configuração de dados para seu conjunto de dados de entrada.

   O seguinte exemplo de entrada é uma linha de sample-dataset.jsonl:

   {
   "document": "23 October 2015 Last updated at 17:44
       BST\nIt's the highest rating a tropical storm
       can get and is the first one of this magnitude
       to hit mainland Mexico since 1959.\nBut how are
       the categories decided and what do they mean?
       Newsround reporter Jenny Lawrence explains.",
   "summary": "Hurricane Patricia has been rated as
       a category 5 storm.",
   "id": "34615665",
   }

   O exemplo de entrada anterior contém o texto a ser resumido dentro da chave document. A referência a ser comparada com a resposta do seu modelo está na chave summary. Você deve usar essas chaves em sua configuração de dados para especificar quais colunas contêm as informações FMEval necessárias para avaliar a resposta do modelo.

   A configuração de dados deve identificar o texto que seu modelo deve resumir em model_input_location. Você deve identificar o valor de referência com target_output_location.

   O exemplo de configuração de dados a seguir se refere ao exemplo de entrada anterior para especificar as colunas necessárias para uma tarefa de resumo de texto, o nome, o identificador uniforme de recursos (URI) e o tipo MIME:

   config = DataConfig(
   dataset_name="sample-dataset",
   dataset_uri="sample-dataset.jsonl",
   dataset_mime_type=MIME_TYPE_JSONLINES,
   model_input_location="document",
   target_output_location="summary"
   )

   Para obter mais informações sobre as informações da coluna necessárias para outras tarefas, consulte a seção Usar um conjunto de dados de entrada personalizado em Avaliação de modelo automática.

3. Configure um ModelRunner personalizado, conforme mostrado no código de seguinte exemplo:

   bedrock_model_runner = BedrockModelRunner(
   model_id=model_id,
   output='completion',
   content_template='{"prompt": $prompt, "max_tokens_to_sample": 500}'
   )

   O código de exemplo anterior especifica o seguinte:

   • model_id: O ID usado para especificar seu modelo.

   • output: Captura a saída do modelo Claude 2 da Anthropic, que retorna sua resposta em uma chave completion.

   • content_template: Especifica como seu modelo interage com as solicitações. O modelo de configuração de exemplo é detalhado apenas para explicar o exemplo anterior e não é obrigatório.

     • No exemplo content_template anterior, o seguinte se aplica:

       • A variável prompt especifica o prompt de entrada, que captura a solicitação feita pelo usuário.

       • A variável max_tokens_to_sample especifica o número máximo de tokens para 500, a fim de limitar o comprimento da resposta.

         Para obter mais informações sobre os parâmetros que você pode especificar em sua solicitação, consulte Modelos Claude da Anthropic.

       O formato do parâmetro content_template depende das entradas e dos parâmetros aceitos pelo seu LLM. Neste tutorial, o modelo Claude 2 da Anthropic usa o seguinte content_template:

          "content_template": "{\"prompt\": $prompt, \"max_tokens_to_sample\": 500}"

       Como outro exemplo, o modelo Falcon 7b pode ser compatível com o seguinte content_template:

       "content_template": "{\"inputs\": $prompt, \"parameters\":{\"max_new_tokens\": \
       10, \"top_p\": 0.9, \"temperature\": 0.8}}"

Defina e execute seu algoritmo de avaliação

1. Defina seu algoritmo de avaliação. O seguinte exemplo mostra como definir um algoritmo SummarizationAccuracy, que é usado para determinar a precisão das tarefas de resumo de texto:

   eval_algo = SummarizationAccuracy(SummarizationAccuracyConfig())

   Para exemplos de algoritmos que calculam métricas para outras tarefas de avaliação, consulte Avaliar seu modelo em Use a biblioteca fmeval para executar uma avaliação automática.

2. Execute seu algoritmo de avaliação. O seguinte exemplo de código usa a configuração de dados que foi definida anteriormente e uma prompt_template que usa as chaves Human e Assistant:

   eval_output = eval_algo.evaluate(model=bedrock_model_runner,
   dataset_config=config,
   prompt_template="Human: $feature\n\nAssistant:\n", save=True)

   No exemplo de código anterior, feature contém o prompt no formato esperado pelo modelo do Amazon Bedrock.

1. Analise um relatório de avaliação do objeto eval_output retornado pelo algoritmo de avaliação da seguinte forma:

   # parse report
   print(json.dumps(eval_output, default=vars, indent=4))

   O comando anterior retorna a seguinte saída:

   [
   {
       "eval_name": "summarization_accuracy",
       "dataset_name": "sample-dataset",
       "dataset_scores": [
           {
               "name": "meteor",
               "value": 0.2048823008681274
           },
           {
               "name": "rouge",
               "value": 0.03557697913367101
           },
           {
               "name": "bertscore",
               "value": 0.5406564395678671
           }
       ],
       "prompt_template": "Human: $feature\n\nAssistant:\n",
       "category_scores": null,
       "output_path": "/tmp/eval_results/summarization_accuracy_sample_dataset.jsonl",
       "error": null
   }
   ]

   O exemplo de saída anterior exibe as três pontuações de precisão: Meteor, Rouge, e BERTScore, a entradaprompt_template, category_score se você solicitou uma, quaisquer erros, e output_path a. Você usará o output_path para criar um Pandas DataFrame na próxima etapa.

2. Importe seus resultados, leia-os em um DataFrame e anexe as pontuações de precisão à entrada do modelo, à saída do modelo e à saída desejada da seguinte forma:

   import pandas as pd
   
   data = []
   with open("/tmp/eval_results/summarization_accuracy_sample_dataset.jsonl", "r") as file:
   for line in file:
       data.append(json.loads(line))
   df = pd.DataFrame(data)
   df['meteor_score'] = df['scores'].apply(lambda x: x[0]['value'])
   df['rouge_score'] = df['scores'].apply(lambda x: x[1]['value'])
   df['bert_score'] = df['scores'].apply(lambda x: x[2]['value'])
   df

   Nesta invocação, o exemplo de código anterior retorna a seguinte saída (contratada para fins de brevidade):

   model_input     model_output     target_output     prompt     scores     meteor_score     rouge_score     bert_score
   0     John Edward Bates, formerly of Spalding, Linco...     I cannot make any definitive judgments, as th...     A former Lincolnshire Police officer carried o...     Human: John Edward Bates, formerly of Spalding...     [{'name': 'meteor', 'value': 0.112359550561797...     0.112360     0.000000     0.543234 ...
   1     23 October 2015 Last updated at 17:44 BST\nIt'...     Here are some key points about hurricane/trop...     Hurricane Patricia has been rated as a categor...     Human: 23 October 2015 Last updated at 17:44 B...     [{'name': 'meteor', 'value': 0.139822692925566...     0.139823     0.017621     0.426529 ...
   2     Ferrari appeared in a position to challenge un...     Here are the key points from the article:\n\n...     Lewis Hamilton stormed to pole position at the...     Human: Ferrari appeared in a position to chall...     [{'name': 'meteor', 'value': 0.283411142234671...     0.283411     0.064516     0.597001 ...
   3     The Bath-born player, 28, has made 36 appearan...     Okay, let me summarize the key points from th...     Newport Gwent Dragons number eight Ed Jackson ...     Human: The Bath-born player, 28, has made 36 a...     [{'name': 'meteor', 'value': 0.089020771513353...     0.089021     0.000000     0.533514 ...
   ...

   A saída do seu modelo pode ser diferente da saída de amostra anterior.

   Para um notebook que contém os exemplos de código fornecidos nesta seção, consulte bedrock-claude-summarization-accuracy.ipnyb.