As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Avalie um JumpStart modelo para estereotipagem imediata Você pode usar um `ModelRunner` invólucro de alto nível para avaliar um SageMaker JumpStart modelo da Amazon para estereotipagem imediata. O algoritmo de estereotipagem de prompt calcula a probabilidade de seu modelo codificar vieses em sua resposta. Esses preconceitos incluem raça, gênero, orientação sexual, religião, idade, nacionalidade, deficiência, aparência física e status socioeconômico. Este tutorial mostra como carregar o modelo [Falcon 7-B](https://huggingface.co/tiiuae/falcon-7b) do [Technology Innovation Institute](https://www.tii.ae/), disponível em JumpStart, e solicitar que esse modelo gere respostas às solicitações. Em seguida, o tutorial mostra como avaliar as respostas para estereotipagem de prompts em relação ao conjunto de dados de desafio de código aberto [CrowS-Pairs](https://github.com/nyu-mll/crows-pairs). As seções do tutorial mostram como: + Configurar o ambiente + Executar a avaliação de modelo. + Visualizar os resultados da análise. ## Configure o ambiente. **Pré-requisitos** + Use um ambiente de kernel Python 3.10 de base e uma instância do Amazon Elastic Compute Cloud (Amazon EC2) `ml.g4dn.2xlarge` antes de iniciar o tutorial. Para obter mais informações sobre tipos de instância e seus casos de uso recomendados, consulte [Tipos de instância disponíveis para uso com notebooks Amazon SageMaker Studio Classic](notebooks-available-instance-types.md). **Instalar bibliotecas necessárias** 1. Instale a SageMaker IA e outras bibliotecas necessárias em seu código da seguinte maneira: `fmeval` ``` !pip3 install sagemaker !pip3 install -U pyarrow !pip3 install -U accelerate !pip3 install "ipywidgets>=8" !pip3 install jsonlines !pip install fmeval !pip3 install boto3==1.28.65 import sagemaker ``` 1. Baixe o conjunto de dados `JSON Lines` [crows-pairs\_sample.jsonl](https://github.com/aws/fmeval/blob/main/examples/crows-pairs_sample.jsonl) em seu diretório de trabalho atual. 1. Verifique se seu ambiente contém o arquivo de entrada de amostra usando o código a seguir: ``` import glob # Check for fmeval wheel and built-in dataset if not glob.glob("crows-pairs_sample.jsonl"): print("ERROR - please make sure file exists: crows-pairs_sample.jsonl") ``` 1. Defina um JumpStart modelo da seguinte forma: ``` from sagemaker.jumpstart.model import JumpStartModel model_id, model_version, = ( "huggingface-llm-falcon-7b-instruct-bf16", "*", ) ``` 1. Implante o JumpStart modelo e crie um endpoint da seguinte forma: ``` my_model = JumpStartModel(model_id=model_id) predictor = my_model.deploy() endpoint_name = predictor.endpoint_name ``` 1. Defina um prompt e o formato da solicitação do modelo, ou carga útil, da seguinte forma: ``` prompt = "London is the capital of" payload = { "inputs": prompt, "parameters": { "do_sample": True, "top_p": 0.9, "temperature": 0.8, "max_new_tokens": 1024, "decoder_input_details" : True, "details" : True }, } ``` No exemplo de código anterior, os seguintes parâmetros estão incluídos na solicitação do modelo: + `do_sample`: Instrui o modelo a extrair amostras dos resultados brutos do modelo (antes da normalização) durante a inferência do modelo para introduzir diversidade e criatividade nas respostas do modelo. O padrão é `False`. Se você definiu `do_sample` como `True`, deverá especificar um valor para um dos seguintes parâmetros: `temperature`, `top_k`, `top_p` ou `typical_p`. + `top_p`: Controla a aleatoriedade limitando o conjunto de tokens a serem considerados ao gerar o próximo token. Valores mais altos de `top_p` permitem um conjunto com um vocabulário mais amplo. Valores mais baixos restringem o conjunto de tokens a palavras mais prováveis. Os intervalos para `top_p` são maiores que `0` e menores que `1`. + `temperature`: Controla a aleatoriedade do texto gerado. Valores mais altos de `temperature` instruem o modelo a gerar respostas mais aleatórias e diversas. Valores mais baixos geram respostas mais previsíveis. Os valores para `temperature` devem ser positivos. + `max_new_tokens`: Limita o comprimento da resposta limitando o número de tokens retornados pelo seu modelo. O padrão é `20`. + `decoder_input_details`— Retorna informações sobre as probabilidades logarítmicas atribuídas pelo modelo a cada próximo token potencial e ao token IDs correspondente. Se `decoder_input_details` estiver definido como `True`, você também deverá definir `details` como `True` para receber os detalhes solicitados. O padrão é `False`. Para obter mais informações sobre os parâmetros do modelo `Hugging Face`, consulte [types.py](https://github.com/huggingface/text-generation-inference/blob/v0.9.3/clients/python/text_generation/types.py#L8). ## Enviar uma solicitação de inferência de amostra Para testar seu modelo, envie uma solicitação de amostra para ele e registre a resposta do modelo da seguinte forma: ``` response = predictor.predict(payload) print(response[0]["generated_text"]) ``` No exemplo de código anterior, se seu modelo forneceu a resposta `[{"response": "this is the output"}]`, a instrução `print` retornará `this is the output`. ## Configurar FMEval 1. Carregue as bibliotecas necessárias para serem executadas da FMEval seguinte maneira: ``` import fmeval from fmeval.data_loaders.data_config import DataConfig from fmeval.model_runners.sm_jumpstart_model_runner import JumpStartModelRunner from fmeval.constants import MIME_TYPE_JSONLINES from fmeval.eval_algorithms.prompt_stereotyping import PromptStereotyping, PROMPT_STEREOTYPING from fmeval.eval_algorithms import EvalAlgorithm ``` 1. Defina a configuração de dados para seu conjunto de dados de entrada. Se você não usa um conjunto de dados integrado, sua configuração de dados deve identificar a coluna que contém mais vieses em `sent_more_input_location`. Você também deve identificar a coluna que contém menos vieses em `sent_less_input_location`. Se você estiver usando um conjunto de dados integrado do JumpStart, esses parâmetros serão transmitidos FMEval automaticamente por meio dos metadados do modelo. Especifique as colunas `sent_more_input_location` e `sent_less_input_location` para uma tarefa de estereotipagem de prompt, o nome, o identificador uniforme de recursos (URI) e o tipo `MIME`. ``` config = DataConfig( dataset_name="crows-pairs_sample", dataset_uri="crows-pairs_sample.jsonl", dataset_mime_type=MIME_TYPE_JSONLINES, sent_more_input_location="sent_more", sent_less_input_location="sent_less", category_location="bias_type", ) ``` Para obter mais informações sobre as informações da coluna que outras tarefas exigem, consulte a seção **Usar um conjunto de dados de entrada personalizado** em [Use um conjunto de dados de entrada personalizado](clarify-foundation-model-evaluate-auto-lib-custom.md#clarify-foundation-model-evaluate-auto-lib-custom-input). 1. Configure um `ModelRunner` personalizado, conforme mostrado no código de seguinte exemplo: ``` js_model_runner = JumpStartModelRunner( endpoint_name=endpoint_name, model_id=model_id, model_version=model_version, output='[0].generated_text', log_probability='[0].details.prefill[*].logprob', content_template='{"inputs": $prompt, "parameters": {"do_sample": true, "top_p": 0.9, "temperature": 0.8, "max_new_tokens": 1024, "decoder_input_details": true,"details": true}}', ) ``` O código de exemplo anterior especifica o seguinte: + `endpoint_name`: O nome do endpoint que você criou na etapa anterior de **instalação de bibliotecas necessárias**. + `model_id`: O ID usado para especificar seu modelo. Esse parâmetro foi especificado quando o JumpStart modelo foi definido. + `model_version`: A versão do seu modelo usada para especificá-lo. Esse parâmetro foi especificado quando o JumpStart modelo foi definido. + `output`: Captura a saída do [modelo Falcon 7b](https://huggingface.co/tiiuae/falcon-7b), que retorna sua resposta em uma chave `generated_text`. Se seu modelo forneceu a resposta `[{"generated_text": "this is the output"}]`, então `[0].generated_text` retornará `this is the output`. + `log_probability`— Captura a probabilidade logarítmica retornada por esse JumpStart modelo. + `content_template`: Especifica como seu modelo interage com as solicitações. O modelo de configuração de exemplo é detalhado somente para explicar o exemplo anterior e não é obrigatório. Os parâmetros no modelo do conteúdo são os mesmos declarados para `payload`. Para obter mais informações sobre os parâmetros do modelo `Hugging Face`, consulte [types.py](https://github.com/huggingface/text-generation-inference/blob/v0.9.3/clients/python/text_generation/types.py#L8). 1. Configure o relatório de avaliação e salve-o em um diretório, conforme mostrado no seguinte exemplo de código: ``` import os eval_dir = "results-eval-prompt-stereotyping" curr_dir = os.getcwd() eval_results_path = os.path.join(curr_dir, eval_dir) + "/" os.environ["EVAL_RESULTS_PATH"] = eval_results_path if os.path.exists(eval_results_path): print(f"Directory '{eval_results_path}' exists.") else: os.mkdir(eval_results_path) ``` 1. Configure um fator de paralelização da seguinte forma: ``` os.environ["PARALLELIZATION_FACTOR"] = "1" ``` Um `PARALLELIZATION_FACTOR` é um multiplicador do número de lotes simultâneos enviados para sua instância de computação. Se o seu hardware permitir a paralelização, você poderá 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 AWS Lambda para fontes de eventos do Kinesis e](https://aws.amazon.com/blogs/compute/new-aws-lambda-scaling-controls-for-kinesis-and-dynamodb-event-sources/) do DynamoDB. ## Executar a avaliação de modelo 1. Defina seu algoritmo de avaliação. O seguinte exemplo mostra como definir um algoritmo `PromptStereotyping`: ``` eval_algo = PromptStereotyping() ``` 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](clarify-foundation-model-evaluate-auto-lib.md). 1. Execute seu algoritmo de avaliação. O exemplo de código abaixo usa o modelo e a configuração de dados que foram definidos anteriormente, além de um `prompt_template` que usa `feature` para transmitir seu prompt ao modelo da seguinte forma: ``` eval_output = eval_algo.evaluate(model=js_model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` A saída do seu modelo pode ser diferente da saída de amostra anterior. ## Visualizar os resultados da análise 1. Analise um relatório de avaliação do objeto `eval_output` retornado pelo algoritmo de avaliação da seguinte forma: ``` import json print(json.dumps(eval_output, default=vars, indent=4)) ``` O comando anterior retorna a seguinte saída (condensada para brevidade): ``` [ { "eval_name": "prompt_stereotyping", "dataset_name": "crows-pairs_sample", "dataset_scores": [ { "name": "prompt_stereotyping", "value": 0.6666666666666666 } ], "prompt_template": "$feature", "category_scores": [ { "name": "disability", "scores": [ { "name": "prompt_stereotyping", "value": 0.5 } ] }, ... ], "output_path": "/home/sagemaker-user/results-eval-prompt-stereotyping/prompt_stereotyping_crows-pairs_sample.jsonl", "error": null } ] ``` O exemplo de saída anterior exibe uma pontuação geral para o conjunto de dados após `"name": prompt_stereotyping`. Essa pontuação é a diferença normalizada nas probabilidades de log entre a resposta do modelo, fornecendo **mais** versus menos desvio. Se a pontuação for maior que `0.5`, isso significa que a resposta do seu modelo tem maior probabilidade de retornar uma resposta contendo mais desvio. Se a pontuação for menor que `0.5`, é mais provável que seu modelo retorne uma resposta contendo menos desvio. Se a pontuação for `0.5`, a resposta do modelo não contém desvio conforme medido pelo conjunto de dados de entrada. Você usará o `output_path` para criar um `DataFrame` do `Pandas` na próxima etapa. 1. Importe seus resultados, leia-os em um `DataFrame` e anexe as pontuações de estereotipagem de prompt à entrada do modelo, à saída do modelo e à saída desejada da seguinte forma: ``` import pandas as pd data = [] with open(os.path.join(eval_results_path, "prompt_stereotyping_crows-pairs_sample.jsonl"), "r") as file: for line in file: data.append(json.loads(line)) df = pd.DataFrame(data) df['eval_algo'] = df['scores'].apply(lambda x: x[0]['name']) df['eval_score'] = df['scores'].apply(lambda x: x[0]['value']) df ``` Para um notebook que contém os exemplos de código fornecidos nesta seção, consulte [jumpstart-falcon-stereotyping.ipnyb](https://github.com/aws/fmeval/blob/main/examples/jumpstart-falcon-stereotyping.ipynb).