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á. # Use a biblioteca `fmeval` para executar uma avaliação automática Usar a biblioteca `fmeval` em seu próprio código oferece maior flexibilidade para personalizar seu fluxo de trabalho. Você pode usar a biblioteca `fmeval` para avaliar qualquer LLM e também para ter mais flexibilidade com seus conjuntos de dados de entrada personalizados. As etapas a seguir mostram como configurar seu ambiente e como executar um fluxo de trabalho inicial e um fluxo de trabalho personalizado usando a biblioteca `fmeval`. ## Conceitos básicos da biblioteca `fmeval` Você pode configurar a avaliação do modelo básico e personalizá-la para seu caso de uso em um caderno do Studio. Sua configuração depende do tipo de tarefa que seu modelo básico foi criado para prever e de como você deseja avaliá-la. FMEval oferece suporte a tarefas abertas de geração, resumo de texto, resposta a perguntas e classificação. As etapas nesta seção mostram como configurar um fluxo de trabalho inicial. Esse fluxo de trabalho inicial inclui a configuração do seu ambiente e a execução de um algoritmo de avaliação usando um modelo básico do Amazon Bedrock JumpStart ou um modelo com conjuntos de dados integrados. Se você precisar usar um conjunto de dados de entrada e um fluxo de trabalho personalizados para um caso de uso mais específico, consulte [Personalize seu fluxo de trabalho usando a biblioteca `fmeval`](clarify-foundation-model-evaluate-auto-lib-custom.md). ## Configure o ambiente. Se você não quiser executar uma avaliação de modelo em um caderno do Studio, pule para a etapa 11 na seção **Começar a usar o Studio**. **Pré-requisitos** + Para executar uma avaliação de modelo em uma interface de usuário do Studio, seu perfil AWS Identity and Access Management (IAM) e qualquer conjunto de dados de entrada devem ter as permissões corretas. Se você não tiver um domínio de SageMaker AI ou uma função do IAM, siga as etapas em[Guia para se configurar com o Amazon SageMaker AI](gs.md). **Para definir permissões para um bucket do Amazon S3** Depois que seu domínio e função forem criados, use as etapas a seguir para adicionar as permissões necessárias para avaliar seu modelo. 1. Abra o console do Amazon SageMaker AI em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/). 1. No painel de navegação, insira **S3** na barra de pesquisa da parte superior da página. 1. Escolha **S3** em **Serviços**. 1. Escolha **Buckets** no painel de navegação. 1. Na seção **Buckets de uso geral**, em **Nome**, escolha o nome do bucket do S3 que você deseja usar para armazenar a entrada e a saída do modelo no console. Se você não tiver um bucket do S3, faça o seguinte: 1. Selecione **Criar bucket** para abrir a nova página **Criar bucket**. 1. Na seção **Configuração geral**, em **Região da AWS **, selecione a região da AWS em que seu modelo de base está localizado. 1. Nomeie seu bucket do S3 no campo de inserção **Nome do bucket**. 1. Aceite todas as opções padrão. 1. Selecione **Criar bucket**. 1. Na seção **Buckets de uso geral**, em **Nome**, selecione o nome do bucket do S3 que você criou. 1. Escolha a aba **Permissões**. 1. Role até a seção **Compartilhamento de recursos de origem cruzada (CORS)** na parte inferior da janela. Escolha **Editar**. 1. Para adicionar permissões ao seu bucket para avaliações básicas, certifique-se de que o código a seguir apareça no campo de inserção. Você também pode copiar e colar o seguinte no campo de inserção: ``` [ { "AllowedHeaders": [ "*" ], "AllowedMethods": [ "GET", "PUT", "POST", "DELETE" ], "AllowedOrigins": [ "*" ], "ExposeHeaders": [ "Access-Control-Allow-Origin" ] } ] ``` 1. Escolha **Salvar alterações**. **Para adicionar permissões à sua política do IAM** 1. Na barra de pesquisa da parte superior da tela, insira **IAM**. 1. Em **Serviços**, selecione **Identity and Access Management (IAM)**. 1. Escolha **Políticas** no painel de navegação. 1. Insira [AmazonSageMakerFullAccess](https://docs.aws.amazon.com/sagemaker/latest/dg/security-iam-awsmanpol.html#security-iam-awsmanpol-AmazonSageMakerFullAccess)na barra de pesquisa. Selecione o botão ao lado da política que aparecer. O botão **Ações** pode ser selecionado agora. 1. Escolha a seta para baixo ao lado de **Ações**. São exibidas duas opções. 1. Escolha **Anexar**. 1. Na lista do IAM que aparecer, pesquise o nome do perfil que você criou. Marque a caixa de seleção próxima ao nome. 1. Escolha **Anexar política**. **Conceitos básicos do Studio** 1. Na barra de pesquisa da parte superior da tela, insira **SageMaker AI**. 1. Em **Serviços**, selecione **Amazon SageMaker AI**. 1. Do painel de navegação, escolha **Studio**. 1. Escolha seu domínio na seção **Começar**, depois de expandir a seta para baixo em **Selecionar domínio**. 1. Escolha seu perfil de usuário na seção **Começar** depois de expandir a seta para baixo em **Selecionar perfil de usuário**. 1. Escolha **Abrir Studio** para abrir a página inicial do Studio. 1. Selecione o navegador de arquivos no painel de navegação e navegue até o diretório raiz. 1. Selecione **Criar caderno**. 1. Na caixa de diálogo do ambiente do caderno que se abre, selecione a imagem **Ciência de dados 3.0**. 1. Escolha **Selecionar**. 1. Instale o pacote `fmeval` em seu ambiente de desenvolvimento, conforme mostrado no seguinte exemplo de código: ``` !pip install fmeval ``` **nota** Instale a biblioteca `fmeval` em um ambiente que usa Python 3.10. Para obter mais informações sobre os requisitos necessários para a execução do `fmeval`, consulte [Dependências `fmeval`](https://github.com/aws/fmeval/blob/main/pyproject.toml). ## Configurar o `ModelRunner` FMEval usa um wrapper de alto nível chamado `ModelRunner` para compor a entrada, invocar e extrair a saída do seu modelo. O pacote `fmeval` pode avaliar qualquer LLM, no entanto, o procedimento de configuração do `ModelRunner` depende do tipo de modelo que você deseja avaliar. Esta seção explica como configurar `ModelRunner` um modelo JumpStart ou Amazon Bedrock. Se você quiser usar um conjunto de dados de entrada personalizado e `ModelRunner` personalizado, consulte[Personalize seu fluxo de trabalho usando a biblioteca `fmeval`](clarify-foundation-model-evaluate-auto-lib-custom.md). ### Use um JumpStart modelo Para usar `ModelRunner` para avaliar um JumpStart modelo, criar ou fornecer um endpoint, definir o modelo e o conjunto de dados incorporado, configurar e testar. `ModelRunner` **Defina um JumpStart modelo e configure um ModelRunner** 1. Forneça um endpoint fazendo uma das seguintes ações: + Especifique o [EndpointName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#API_runtime_InvokeEndpoint_RequestSyntax)para um JumpStart endpoint existente`model_id`, o e. `model_version` + Especifique `model_id` e `model_version` para seu modelo e crie um JumpStart endpoint. O exemplo de código a seguir mostra como criar um endpoint para um [https://aws.amazon.com/blogs/machine-learning/llama-2-foundation-models-from-meta-are-now-available-in-amazon-sagemaker-jumpstart/](https://aws.amazon.com/blogs/machine-learning/llama-2-foundation-models-from-meta-are-now-available-in-amazon-sagemaker-jumpstart/)que está disponível por meio JumpStart de. ``` import sagemaker from sagemaker.jumpstart.model import JumpStartModel #JumpStart model and version model_id, model_version = "meta-textgeneration-llama-2-7b-f", "*" my_model = JumpStartModel(model_id=model_id) predictor = my_model.deploy() endpoint_name = predictor.endpoint_name # Accept the EULA, and test the endpoint to make sure it can predict. predictor.predict({"inputs": [[{"role":"user", "content": "Hello how are you?"}]]}, custom_attributes='accept_eula=true') ``` O exemplo de código anterior se refere ao EULA, que significa end-use-license-agreement (EULA). O EULA pode ser encontrado na descrição do cartão do modelo que você está usando. Para usar alguns JumpStart modelos, você deve especificar`accept_eula=true`, conforme mostrado na chamada anterior para`predict`. Para obter mais informações sobre o EULA, consulte a seção **Licenças e fontes de modelos** em [Fontes de modelos e contratos de licença](jumpstart-foundation-models-choose.md). Você pode encontrar uma lista dos JumpStart modelos disponíveis em [Algoritmos integrados com tabela de modelos pré-treinada](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html#built-in-algorithms-with-pre-trained-model-table). 1. Configure o `ModelRunner` usando o `JumpStartModelRunner`, conforme mostrado no exemplo de configuração a seguir: ``` from fmeval.model_runners.sm_jumpstart_model_runner import JumpStartModelRunner js_model_runner = JumpStartModelRunner( endpoint_name=endpoint_name, model_id=model_id, model_version=model_version ) ``` No exemplo de configuração anterior, use os mesmos valores para `endpoint_name`, `model_id` e `model_version` que você usou para criar o endpoint. 1. Teste seu `ModelRunner`. Envie uma solicitação de amostra para o seu modelo conforme mostrado no código de seguinte exemplo: ``` js_model_runner.predict("What is the capital of London") ``` ### Use um modelo do Amazon Bedrock Para avaliar um modelo do Amazon Bedrock, você deve definir o modelo e o conjunto de dados integrado, além de configurar o `ModelRunner`. **Defina um modelo Amazon Bedrock e configure um ModelRunner** 1. Para definir e registrar detalhes do modelo, use o seguinte exemplo de código para um modelo Titan que está disponível no Amazon Bedrock: ``` import boto3 import json bedrock = boto3.client(service_name='bedrock') bedrock_runtime = boto3.client(service_name='bedrock-runtime') model_id = "amazon.titan-tg1-large" accept = "application/json" content_type = "application/json" print(bedrock.get_foundation_model(modelIdentifier=modelId).get('modelDetails')) ``` No exemplo de código anterior, o parâmetro `accept` especifica o formato dos dados que você deseja usar para avaliar seu LLM. O `contentType` especifica o formato dos dados de entrada na solicitação. Apenas `MIME_TYPE_JSON` é compatível com `accept` e `contentType` para os modelos do Amazon Bedrock. Para mais informações sobre esses parâmetros, consulte [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html#API_runtime_InvokeModelWithResponseStream_RequestSyntax). 1. Para configurar `ModelRunner`, use o `BedrockModelRunner`, conforme mostrado no exemplo de configuração a seguir: ``` from fmeval.model_runners.bedrock_model_runner import BedrockModelRunner bedrock_model_runner = BedrockModelRunner( model_id=model_id, output='results[0].outputText', content_template='{"inputText": $prompt, "textGenerationConfig": \ {"maxTokenCount": 4096, "stopSequences": [], "temperature": 1.0, "topP": 1.0}}', ) ``` Parametrize a configuração `ModelRunner` da seguinte maneira: + Use os mesmos valores para `model_id` que você usou para implantar o modelo. + Use `output` para especificar o formato da resposta `json` gerada. Por exemplo, se seu LLM forneceu a resposta `[{"results": "this is the output"}]`, então `output='results[0].outputText'` retornará `this is the output`. + Use `content_template` para especificar como seu LLM interage com as solicitações. O modelo de configuração a seguir é detalhado somente para explicar o exemplo de configuração anterior e não é obrigatório. + No exemplo de configuração anterior, a variável `inputText` especifica o prompt, que captura a solicitação feita pelo usuário. + A variável `textGenerationConfig` especifica como o LLM gera respostas da seguinte forma: + O parâmetro `maxTokenCount` é usado para limitar o comprimento da resposta limitando o número de tokens retornados pelo LLM. + O parâmetro `stopSequences` é usado para especificar uma lista de sequências de caracteres que instruem seu LLM 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. Como exemplo, você pode usar uma sequência de retorno de carro para limitar a resposta do modelo a uma única linha. + O parâmetro `topP` controla a aleatoriedade limitando o conjunto de tokens a serem considerados ao gerar o próximo token. Esse parâmetro aceita valores entre `0.0` e `1.0`. 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. + O parâmetro `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 típicos para `temperature` ficam entre `0.2` e `2.0`. Para obter mais informações sobre parâmetros para um modelo básico específico do Amazon Bedrock, consulte [Parâmetros de inferência para modelos básicos](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html#model-parameters-titan). O formato do parâmetro content\$1template depende das entradas e dos parâmetros aceitos pelo LLM. Por exemplo, o [modelo Anthropic’s Claude 2](https://www.anthropic.com/index/claude-2) pode ser compatível com o seguinte `content_template`: ``` "content_template": "{\"prompt\": $prompt, \"max_tokens_to_sample\": 500}" ``` Como outro exemplo, o [modelo Falcon 7b](https://huggingface.co/tiiuae/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}}" ``` Por fim, teste seu `ModelRunner`. Envie uma solicitação de amostra para o seu modelo conforme mostrado no código de seguinte exemplo: ``` bedrock_model_runner.predict("What is the capital of London?") ``` ## Avaliar seu modelo Depois de configurar seus dados e `ModelRunner`, você pode executar um algoritmo de avaliação nas respostas geradas pelo LLM. Para ver uma lista de todos os algoritmos de avaliação disponíveis, execute o código a seguir: ``` from fmeval.eval_algo_mapping import EVAL_ALGORITHMS print(EVAL_ALGORITHMS.keys()) ``` Cada algoritmo tem uma avaliação e um método `evaluate_sample`. O método `evaluate` calcula uma pontuação para todo o conjunto de dados. O método `evaluate_sample` avalia a pontuação de uma única instância. O método `evaluate_sample` retorna objetos `EvalScore`. Os objetos `EvalScore` contêm pontuações agregadas do desempenho do seu modelo durante a avaliação. O elemento `evaluate_sample` tem os seguintes parâmetros opcionais: + `model_output`: A resposta do modelo para uma única solicitação. + `model_input`: Um prompt contendo a solicitação para seu modelo. + `target_output`: A resposta esperada do prompt contido em `model_input`. O código de seguinte exemplo mostra como usar `evaluate_sample`: ``` #Evaluate your custom sample model_output = model_runner.predict("London is the capital of?")[0] eval_algo.evaluate_sample(target_output="UKEnglandUnited Kingdom", model_output=model_output) ``` O elemento `evaluate` tem os seguintes parâmetros opcionais: + `model`: Uma instância de `ModelRunner` usando o modelo que você deseja avaliar. + `dataset_config`: Configuração do conjunto de dados. Se `dataset_config` não for fornecido, o modelo será avaliado usando todos os conjuntos de dados integrados que estão configurados para essa tarefa. + `prompt_template`: Um modelo usado para gerar prompts. Se `prompt_template` não for fornecido, seu modelo será avaliado usando um modelo de prompt padrão. + `save`: Se definido como `True`, as respostas e pontuações de prompts registradas são salvas no arquivo `EvalAlgorithmInterface.EVAL_RESULTS_PATH`. O padrão é `False`. + `num_records`: O número de registros que são amostrados aleatoriamente do conjunto de dados de entrada para avaliação. O padrão é `300`. O algoritmo `evaluate` retorna uma lista de objetos `EvalOutput` que pode incluir o seguinte: + `eval_name`: o nome do algoritmo de avaliação. `dataset_name`: o nome do conjunto de dados usado pelo algoritmo de avaliação. `prompt_template`: um modelo usado para compor prompts que é consumido se o parâmetro `model_output` não for fornecido no conjunto de dados. Para obter mais informações, consulte `prompt_template` a ** JumpStart `ModelRunner`seção Configurar um**. `dataset_scores`: Uma pontuação agregada calculada em todo o conjunto de dados. `category_scores`: Uma lista de objetos `CategoryScore` que contêm as pontuações de cada categoria no conjunto de dados. `output_path`: O caminho local para o resultado da avaliação. Essa saída contém respostas de prompts com as pontuações da avaliação gravadas. `error`: Uma mensagem de erro de sequência de caracteres para um trabalho de avaliação que falhou. As dimensões a seguir estão disponíveis para a avaliação do modelo: + Precisão + Conhecimento fatual + Estereotipagem de prompts + Robustez semântica + Toxicidade ### Precisão Você pode executar um algoritmo de precisão para uma tarefa de resposta a perguntas, resumo de texto ou classificação. Os algoritmos são diferentes para cada tarefa, a fim de acomodar os diferentes tipos de entrada de dados e problemas da seguinte forma: + Para tarefas de resposta a perguntas, execute o algoritmo `QAAccuracy` com um arquivo `QAAccuracyConfig`. + Para tarefas de resumo de texto, execute o algoritmo `SummarizationAccuracy` com um `SummarizationAccuracyConfig`. + Para tarefas de classificação, execute o algoritmo `ClassificationAccuracy` com um `ClassificationAccuracyConfig`. O algoritmo `QAAccuracy` retorna uma lista de objetos `EvalOutput` que contém uma pontuação de precisão para cada amostra. Para executar o algoritmo de precisão das respostas, instancie a `QAAccuracygeConfig` e transmita um `` ou `None` como o `target_output_delimiter`. O algoritmo de precisão de respostas compara a resposta que seu modelo gera com uma resposta conhecida. Se você passar `` como delimitador de objetivo, o algoritmo classificará a resposta como correta se gerar algum conteúdo separado por `` nela. Se você passar `None` uma string vazia como `target_output_delimiter`, o código gerará um erro. Chame o método `evaluate` e transmita os parâmetros desejados, conforme mostrado no seguinte exemplo de código: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.qa_accuracy import QAAccuracy, QAAccuracyConfig eval_algo = QAAccuracy(QAAccuracyConfig(target_output_delimiter=""))) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` O algoritmo `SummarizationAccuracy` retorna uma lista de objetos `EvalOutput` que contêm pontuações para [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge), [https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor) e [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore). Para obter mais informações sobre essas pontuações, consulte a seção Resumo de texto em [Usar conjuntos de dados de prompts e dimensões de avaliação disponíveis em trabalhos de avaliação de modelo](clarify-foundation-model-evaluate-overview.md). Para executar o algoritmo de precisão do resumo de texto, instancie um `SummarizationAccuracyConfig` e transmita o seguinte: + Especifique o tipo de métrica [https://en.wikipedia.org/wiki/ROUGE_(metric)](https://en.wikipedia.org/wiki/ROUGE_(metric)) que você deseja usar em sua avaliação para `rouge_type`. Você pode escolher `rouge1`, `rouge2` ou `rougeL`. Essas métricas comparam os resumos gerados com os resumos de referência. ROUGE-1 compara os resumos gerados e os resumos de referência usando unigramas sobrepostos (sequências de um item, como “o”, “é”). ROUGE-2 compara os resumos gerados e de referência usando bigramas (grupos de duas sequências, como “o maior”, “é casa”). ROUGE-L compara a sequência de palavras correspondente mais longa. Para obter mais informações sobre ROUGE, consulte [ROUGE: um pacote para avaliações automáticas de resumos](https://aclanthology.org/W04-1013.pdf). + Defina `use_stemmer_for_rouge` como `True` ou `False`. Um truncador remove os afixos das palavras antes de compará-las. Por exemplo, um truncador remove os afixos de “nadando” e “nadou” para que ambos virem “nadar” após o truncamento. + Defina model\$1type\$1for\$1bertscore para o modelo que você deseja usar para calcular um [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore). Você pode escolher [ROBERTA\$1MODEL](https://huggingface.co/docs/transformers/model_doc/roberta) ou o [MICROSOFT\$1DEBERTA\$1MODEL](https://github.com/microsoft/DeBERTa) mais avançado. Por fim, chame o método `evaluate` e transmita os parâmetros desejados, conforme mostrado no seguinte exemplo de código: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.summarization_accuracy import SummarizationAccuracy, SummarizationAccuracyConfig eval_algo = SummarizationAccuracy(SummarizationAccuracyConfig(rouge_type="rouge1",model_type_for_bertscore="MICROSOFT_DEBERTA_MODEL")) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` O algoritmo `ClassificationAccuracy` retorna uma lista de objetos `EvalOutput` que contêm as pontuações de classificação de exatidão, precisão, recordação e precisão balanceada para cada amostra. Para obter mais informações sobre as classificações de descoberta, consulte a seção **Classificação** em [Usar conjuntos de dados de prompts e dimensões de avaliação disponíveis em trabalhos de avaliação de modelo](clarify-foundation-model-evaluate-overview.md). Para executar o algoritmo de classificação de precisão, instancie `ClassificationAccuracyConfig` e passe uma estratégia de média para `multiclass_average_strategy`. Você pode escolher `micro`, `macro`, `samples`, `weighted` ou `binary`. O valor padrão é `micro`. Em seguida, passe uma lista contendo os nomes das colunas que contêm os rótulos verdadeiros de suas categorias de classificação para valid\$1labels. Por fim, chame o método `evaluate` e transmita os parâmetros desejados, conforme mostrado no seguinte exemplo de código: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.classification_accuracy import ClassificationAccuracy, ClassificationAccuracyConfig eval_algo = ClassificationAccuracy(ClassificationAccuracyConfig(multiclass_average_strategy="samples",valid_labels=["animal_type","plant_type","fungi_type"])) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` ### Conhecimento fatual Você pode executar o algoritmo de conhecimento fatual para a geração aberta. Para executar o algoritmo de conhecimento fatual, instancie um `FactualKnowledgeConfig` e, opcionalmente, passe uma string delimitadora (por padrão, ``). O algoritmo de conhecimento fatual compara a resposta que seu modelo gera com uma resposta conhecida. O algoritmo classifica a resposta como correta caso seja gerado algum conteúdo separado pelo delimitador na resposta. Se você passar `None` como `target_output_delimiter`, o modelo deverá gerar a mesma resposta para ser pontuada como correta. Por fim, chame o método `evaluate` e passe os parâmetros desejados. O conhecimento fatual retorna uma lista de objetos `EvalScore`. Eles contêm pontuações agregadas sobre o quão bem seu modelo é capaz de codificar o conhecimento fatual, conforme descrito na seção **Visão geral da avaliação do modelo básico**. As pontuações variam entre `0` e `1`, com a pontuação mais baixa correspondendo a um menor conhecimento dos fatos do mundo real. O seguinte exemplo de código mostra como avaliar seu LLM usando o algoritmo de conhecimento fatual: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.factual_knowledge import FactualKnowledge, FactualKnowledgeConfig eval_algo = FactualKnowledge(FactualKnowledgeConfig()) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` ### Estereotipagem de prompts Você pode executar o algoritmo de estereotipagem de prompt para geração aberta. Para executar o algoritmo de estereotipagem de prompt, seu `DataConfig` deve identificar as colunas em seu conjunto de dados de entrada que contêm uma frase menos estereotipada em `sent_less_input_location` e uma frase mais estereotipada em `sent_more_output_location`. Para mais informações sobre `DataConfig`, consulte a seção **2 anterior. Configure o `ModelRunner`**. Em seguida, chame o método `evaluate` e passe os parâmetros desejados. A estereotipagem de prompt retorna uma lista de objetos `EvalOutput` que contém uma pontuação para cada registro de entrada e pontuações gerais para cada tipo de desvio. As pontuações são calculadas comparando a probabilidade das frases mais e menos estereotipadas. A pontuação geral relata a frequência com que o modelo preferiu a frase estereotipada, pois ele atribuiu uma probabilidade maior à frase mais estereotipada em comparação com a frase menos estereotipada. Uma pontuação de `0.5` indica que seu modelo é imparcial ou que prefere frases mais e menos estereotipadas em taxas iguais. Uma pontuação maior que `0.5` indica que seu modelo provavelmente gerará uma resposta mais estereotipada. Pontuações menores que `0.5` indicam que seu modelo provavelmente gerará uma resposta menos estereotipada. O seguinte exemplo de código mostra como avaliar seu LLM usando o algoritmo de estereotipagem de prompt: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.prompt_stereotyping import PromptStereotyping eval_algo = PromptStereotyping() eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` ### Robustez semântica Você pode executar um algoritmo de robustez semântica para qualquer FMEval tarefa, mas seu modelo deve ser determinístico. Um modelo determinístico é aquele que sempre gera a mesma saída para a mesma entrada. Normalmente, pode-se conseguir o determinismo definindo uma semente aleatória no processo de decodificação. Os algoritmos são diferentes para cada tarefa, a fim de acomodar os diferentes tipos de entrada de dados e problemas da seguinte forma: + Para geração aberta, resposta a perguntas ou classificação de tarefas, execute o algoritmo `GeneralSemanticRobustness` com um arquivo `GeneralSemanticRobustnessConfig`. + Para resumo de texto, execute o algoritmo `SummarizationAccuracySemanticRobustness` com um arquivo `SummarizationAccuracySemanticRobustnessConfig`. O algoritmo `GeneralSemanticRobustness` retorna uma lista de objetos `EvalScore` que contêm precisão com valores entre `0` e `1` quantificando a diferença entre as saídas alteradas e não alteradas do modelo. Para executar o algoritmo de robustez semântica geral, instancie um `GeneralSemanticRobustnessConfig` e passe `perturbation_type`. Você pode escolher uma das seguintes opções para `perturbation_type`: + `Butterfinger`: Uma alteração que imita erros ortográficos usando trocas de caracteres com base na distância do teclado. Insira a probabilidade de um determinado caractere ser alterado. Butterfinger é o valor padrão para `perturbation_type`. + `RandomUpperCase`: Uma alteração que muda uma fração de caracteres para maiúsculas. Insira um decimal de `0` até `1`. + `WhitespaceAddRemove`: A probabilidade de um caractere de espaço em branco ser adicionado na frente de um caractere que não seja de espaço em branco. Você também pode especificar os seguintes parâmetros: + `num_perturbations`: O número de alterações para cada amostra a ser introduzida no texto gerado. O padrão é `5`. + `butter_finger_perturbation_prob`: A probabilidade de um caractere ser alterado. Usado somente quando `perturbation_type` é `Butterfinger`. O padrão é `0.1`. + `random_uppercase_corrupt_proportion`: A fração de caracteres a ser alterada para maiúsculas. Usado somente quando `perturbation_type` é `RandomUpperCase`. O padrão é `0.1`. + `whitespace_add_prob`: Dado um espaço em branco, a probabilidade de removê-lo de uma amostra. Usado somente quando `perturbation_type` é `WhitespaceAddRemove`. O padrão é `0.05`. + `whitespace_remove_prob`: Dado um espaço não branco, a probabilidade de adicionar um espaço em branco na frente dele. Usado somente quando `perturbation_type` é `WhitespaceAddRemove`. O padrão é `0.1`. Por fim, chame o método `evaluate` e transmita os parâmetros desejados, conforme mostrado no seguinte exemplo de código: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.general_semantic_robustness import GeneralSemanticRobustness, GeneralSemanticRobustnessConfig eval_algo = GeneralSemanticRobustness(GeneralSemanticRobustnessConfig(perturbation_type="RandomUpperCase",num_perturbations=2,random_uppercase_corrupt_proportion=0.3))) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` O algoritmo `SummarizationAccuracySemanticRobustness` retorna uma lista de objetos `EvalScore` que contêm a diferença (ou delta) entre os valores [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge), [https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor) e [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore) e entre os resumos gerados e de referência. Para obter mais informações sobre essas pontuações, consulte a seção **Resumo de texto** em [Usar conjuntos de dados de prompts e dimensões de avaliação disponíveis em trabalhos de avaliação de modelo](clarify-foundation-model-evaluate-overview.md). Para executar o algoritmo de robustez semântica de resumo de texto, instancie `SummarizationAccuracySemanticRobustnessConfig` e passe `perturbation_type`. Você pode escolher uma das seguintes opções para `perturbation_type`: + `Butterfinger`: Uma alteração que imita erros ortográficos usando trocas de caracteres com base na distância do teclado. Insira a probabilidade de um determinado caractere ser alterado. `Butterfinger` é o valor padrão para `perturbation_type`. + `RandomUpperCase`: Uma alteração que muda uma fração de caracteres para maiúsculas. Insira um decimal de `0` até `1`. + `WhitespaceAddRemove`: Insira a probabilidade de que um caractere de espaço em branco seja adicionado na frente de um caractere que não seja de espaço em branco. Você também pode especificar os seguintes parâmetros: + `num_perturbations`: O número de alterações para cada amostra a ser introduzida no texto gerado. O padrão é `5`. + `butter_finger_perturbation_prob`: A probabilidade de um caractere ser alterado. Usado somente quando `perturbation_type` é `Butterfinger`. O padrão é `0.1`. + `random_uppercase_corrupt_proportion`: A fração de caracteres a ser alterada para maiúsculas. Usado somente quando `perturbation_type` é `RandomUpperCase`. O padrão é `0.1`. + `whitespace_add_prob`: Dado um espaço em branco, a probabilidade de removê-lo de uma amostra. Usado somente quando `perturbation_type` é `WhitespaceAddRemove`. O padrão é `0.05`. + `whitespace_remove_prob`: Dado um espaço não branco, a probabilidade de adicionar um espaço em branco na frente dele. Usado somente quando `perturbation_type` é `WhitespaceAddRemove`, o padrão é `0.1`. + `rouge_type`: Métricas que comparam resumos gerados com resumos de referência. Especifique o tipo de métrica [https://en.wikipedia.org/wiki/ROUGE_(metric)](https://en.wikipedia.org/wiki/ROUGE_(metric)) que você deseja usar em sua avaliação para `rouge_type`. Você pode escolher `rouge1`, `rouge2` ou `rougeL`. ROUGE-1 compara os resumos gerados e os resumos de referência usando unigramas sobrepostos (sequências de um item, como “o”, “é”). ROUGE-2 compara os resumos gerados e de referência usando bigramas (grupos de duas sequências, como “o maior”, “é casa”). ROUGE-L compara a sequência de palavras correspondente mais longa. Para obter mais informações sobre ROUGE, consulte [ROUGE: um pacote para avaliações automáticas de resumos](https://aclanthology.org/W04-1013.pdf). + Defina `user_stemmer_for_rouge` como `True` ou `False`. Um truncador remove os afixos das palavras antes de compará-las. Por exemplo, um truncador remove os afixos de “nadando” e “nadou” para que ambos virem “nadar” após o truncamento. + Defina `model_type_for_bertscore` para o modelo que você deseja usar para calcular um [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore). Você pode escolher [ROBERTA\$1MODEL](https://huggingface.co/docs/transformers/model_doc/roberta) ou o [MICROSOFT\$1DEBERTA\$1MODEL](https://github.com/microsoft/DeBERTa) mais avançado. Chame o método `evaluate` e transmita os parâmetros desejados, conforme mostrado no seguinte exemplo de código: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.summarization_accuracy_semantic_robustness import SummarizationAccuracySemanticRobustness, SummarizationAccuracySemanticRobustnessConfig eval_algo = SummarizationAccuracySemanticRobustness(SummarizationAccuracySemanticRobustnessConfig(perturbation_type="Butterfinger",num_perturbations=3,butter_finger_perturbation_prob=0.2))) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` ### Toxicidade Você pode executar um algoritmo de toxicidade para geração aberta, resumo de texto ou resposta a perguntas. Há três classes distintas, dependendo da tarefa. + Para geração aberta, execute o algoritmo de toxicidade com um arquivo `ToxicityConfig`. + Para resumo, use a classe `Summarization_Toxicity`. + Para resposta a perguntas, use a classe `QAToxicity`. O algoritmo de toxicidade retorna uma ou mais listas de objetos `EvalScore` (dependendo do detector de toxicidade) que contêm pontuações entre `0` e `1`. Para executar o algoritmo de toxicidade, instancie um `ToxicityConfig` e passe um modelo de toxicidade para usar na avaliação de seu modelo em `model_type`. Você pode escolher o seguinte para `model_type`: + [“detoxify” do Detoxify imparcial da UnitaryAI](https://github.com/unitaryai/detoxify), um classificador de textos com vários rótulos treinado em [Toxic Comment Classification Challenge](https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge) e [Jigsaw Unintended Bias in Toxicity Classification](https://www.kaggle.com/c/jigsaw-unintended-bias-in-toxicity-classification). O modelo fornece pontuações `7` para as seguintes classes: toxicidade, toxicidade severa, obscenidade, ameaça, insulto, conteúdo sexual explícito e ataque de identidade. A seguir está um exemplo de saída do modelo detoxity: ``` EvalScore(name='toxicity', value=0.01936926692724228), EvalScore(name='severe_toxicity', value=3.3755677577573806e-06), EvalScore(name='obscene', value=0.00022437423467636108), EvalScore(name='identity_attack', value=0.0006707844440825284), EvalScore(name='insult', value=0.005559926386922598), EvalScore(name='threat', value=0.00016682750720065087), EvalScore(name='sexual_explicit', value=4.828436431125738e-05) ``` + [`toxigen` para Toxigen-roberta, um classificador de texto binário BERTa baseado em Ro ajustado no ToxiGen conjunto de dados, que contém frases com toxicidade](https://github.com/microsoft/TOXIGEN) sutil e implícita pertencentes a grupos minoritários. `13` Por fim, chame o método `evaluate` e transmita os parâmetros desejados, conforme mostrado no exemplo de código a seguir. ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.toxicity import Toxicity, ToxicityConfig eval_algo = Toxicity(ToxicityConfig(model_type="detoxify")) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ```