Configurar o ambiente Execute a avaliação do seu modelo Veja os resultados da sua análise

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

Você pode usar um ModelRunner wrapper de alto nível para criar uma avaliação personalizada com base em um modelo hospedado fora do. JumpStart

Este tutorial mostra como carregar o modelo Anthropic Claude 2, que está disponível no Amazon Bedrock, e solicitar que esse modelo resuma as solicitações de texto. Em seguida, este tutorial mostra como avaliar a precisão da resposta do modelo usando o Rouge-L, Meteor, e BERTScoreMétricas do .

Os tutoriais mostram como fazer o seguinte:

Configurar o ambiente do
Execute a avaliação do seu modelo.
Visualize os resultados da sua análise.

Configurar o ambiente

Pré-requisitos

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

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

Configuração do Amazon Bedrock

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

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.
Abra o console do Amazon Bedrock.
No Bem-vindo ao Amazon Bedrock! Na seção que se abre, escolha Gerenciar acesso ao modelo.
Na seção Acesso ao modelo exibida, escolha Gerenciar acesso ao modelo.
Na seção Modelos básicos exibida, marque a caixa ao lado de Claude listada na subseção Antrópica de Modelos.
Escolha Solicitar acesso ao modelo.
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.
Talvez seja necessário fazer login novamente Conta da AWS para poder acessar o modelo.

Instale as bibliotecas necessárias

Em seu código, instale as boto3 bibliotecas fmeval e da seguinte forma:
```
!pip install fmeval
!pip3 install boto3==1.28.65
```
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, o seguinte se aplica:
- 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 como2, seu trabalho 200 executará invocações. Você pode aumentar PARALLELIZATION_FACTOR até 10 ou remover totalmente a variável. 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.
Faça o download do JSON Lines conjunto de dados de amostra, sample-dataset.jsonl, em seu diretório de trabalho atual.

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 um exemplo de solicitação de inferência para seu modelo

Defina o modelo e o MIME tipo do seu prompt. Para um modelo Anthropic Claude 2 hospedado no Amazon Bedrock, sua solicitação deve ser estruturada 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.
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. Um exemplo de solicitação com o max_tokens_to_sample conjunto a 500 seguir:
```
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. temperatureIntervalos entre 0 e1, 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 topP permitem um conjunto contendo um vocabulário mais amplo e valores mais baixos restringem o conjunto de símbolos a palavras mais prováveis. Os intervalos de topP são 0 até1, com um valor padrão de1.
- topK— Limita as previsõ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. Os intervalos de topK são 0 até500, com um valor padrão de250.
- max_tokens_to_sample— Limita a duração da resposta limitando o número de tokens retornados pelo seu modelo. Os intervalos de max_tokens_to_sample são 0 até4096, com um valor padrão de200.
- 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 qualquer 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 parar sequências.
Para obter mais informações sobre os parâmetros que você pode especificar em uma solicitação, consulte Modelos antrópicos de Claude.

Configurar FMEval

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

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

O exemplo de entrada a seguir está a uma linha desample-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 document chave. A referência com a qual avaliar a resposta do seu modelo está na summary chave. 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.

Sua configuração de dados deve identificar o texto em que seu modelo deve ser resumido. model_input_location Você deve identificar o valor de referência comtarget_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 do recurso (URI) e o MIME tipo:
```
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 emAvaliação automática do modelo.
Configure um personalizado ModelRunner conforme mostrado no exemplo de código a seguir:
```
bedrock_model_runner = BedrockModelRunner(
model_id=model_id,
output='completion',
content_template='{"prompt": $prompt, "max_tokens_to_sample": 500}'
)
```
O exemplo de código anterior especifica o seguinte:
- model_id— O ID usado para especificar seu modelo.
- output— Captura a saída do modelo Anthropic Claude 2, 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 a seguir apenas para explicar o exemplo anterior e não é obrigatório.
  - No content_template exemplo 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 para500, 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 antrópicos de Claude.
    
    O formato do content_template parâmetro depende das entradas e dos parâmetros suportados pelo seuLLM. 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 suportar o seguinte: content_template
    
    "content_template": "{\"inputs\": $prompt, \"parameters\":{\"max_new_tokens\": \ 10, \"top_p\": 0.9, \"temperature\": 0.8}}"

Execute a avaliação do seu modelo

Defina e execute seu algoritmo de avaliação

Defina seu algoritmo de avaliação. O exemplo a seguir mostra como definir um SummarizationAccuracy algoritmo, 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 emUse a fmeval biblioteca para executar uma avaliação automática.
Execute seu algoritmo de avaliação. O exemplo de código a seguir usa a configuração de dados que foi definida anteriormente e uma prompt_template que usa as Assistant chaves Human and:
```
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 Amazon Bedrock.

Veja os resultados da sua análise

Analise um relatório de avaliação do eval_output objeto 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 etapa seguinte.

Importe seus resultadosDataFrame, leia-os em um e anexe as pontuações de precisão à entrada do modelo, à saída do modelo e à saída alvo 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

Nessa 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.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Avalie um JumpStart modelo para estereotipagem imediata

Solução de problemas