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á.
# Personalize seu fluxo de trabalho usando a biblioteca `fmeval`
Você pode personalizar a avaliação do seu modelo para permitir um modelo que não seja um JumpStart modelo do Amazon Bedrock ou usar um fluxo de trabalho personalizado para avaliação. Se você usa seu próprio modelo, precisa criar um `ModelRunner` personalizado. Se você usar seu próprio conjunto de dados para avaliação, deverá configurar um objeto `DataConfig`. A seção a seguir mostra como formatar seu conjunto de dados de entrada, personalizar um objeto `DataConfig` para usar seu conjunto de dados personalizado e criar um `ModelRunner` personalizado.
## Use um conjunto de dados de entrada personalizado
Se quiser usar seu próprio conjunto de dados para avaliar seu modelo, você deve usar um objeto `DataConfig` para especificar o `dataset_name` e o `dataset_uri` do conjunto de dados que você deseja avaliar. Se você usa um conjunto de dados integrado, o objeto `DataConfig` já está configurado como padrão para algoritmos de avaliação.
Você pode usar um conjunto de dados personalizado sempre que usar a função `evaluate`. Você pode invocar `evaluate` quantas vezes quiser para usar quantos conjuntos de dados desejar.
Configure um conjunto de dados personalizado com sua solicitação de modelo especificada na coluna da pergunta e a resposta alvo especificada na resposta da coluna, da seguinte forma:
```
from fmeval.data_loaders.data_config import DataConfig
from fmeval.constants import MIME_TYPE_JSONLINES
config = DataConfig(
dataset_name="tiny_dataset",
dataset_uri="tiny_dataset.jsonl",
dataset_mime_type=MIME_TYPE_JSONLINES,
model_input_location="question",
target_output_location="answer",
)
```
Veja classe `DataConfig` contém os seguintes parâmetros:
+ `dataset_name`: O nome do conjunto de dados que você deseja usar para avaliar seu LLM.
`dataset_uri`: O caminho local ou o identificador uniforme de recursos (URI) para a localização do seu conjunto de dados no S3.
+ `dataset_mime_type`: O formato de dados de entrada que você deseja usar para avaliar seu LLM. A FMEval biblioteca pode suportar `MIME_TYPE_JSON` tanto `MIME_TYPE_JSONLINES` e.
+ `model_input_location`: (Opcional) O nome da coluna em seu conjunto de dados que contém as entradas ou prompts do modelo que você deseja avaliar.
Use um `model_input_location` que especifique o nome da sua coluna. A coluna deve conter os seguintes valores correspondentes às seguintes tarefas associadas:
+ Para avaliações de **geração aberta**, **toxicidade** e **precisão**, especifique a coluna que contém o **prompt** ao qual seu modelo deve responder.
+ Para uma tarefa de **resposta a perguntas**, especifique a coluna que contém a **pergunta** para a qual seu modelo deve gerar uma resposta.
+ Para uma **tarefa de resumo de texto**, especifique o nome da coluna que contém o **texto** que você deseja que seu modelo resuma.
+ Para uma **tarefa de classificação**, especifique o nome da coluna que contém o **texto** que você deseja que seu modelo classifique.
+ Para avaliações de **conhecimento fatual**, especifique o nome da coluna que contém a **pergunta** para a qual você deseja que o modelo preveja a resposta.
+ Para avaliações de **robustez semântica**, especifique o nome da coluna que contém a **entrada** que você deseja que seu modelo altere.
+ Para avaliações de **estereotipagem de prompt**, use o `sent_more_input_location` e ` sent_less_input_location` em vez de `model_input_location`, conforme mostrado nos parâmetros a seguir.
+ `model_output_location`: (Opcional) O nome da coluna em seu conjunto de dados que contém a saída prevista que você deseja comparar com a saída de referência contida em `target_output_location`. Se você fornecer`model_output_location`, FMEval não enviará uma solicitação ao seu modelo para inferência. Em vez disso, ele usa a saída contida na coluna especificada para avaliar seu modelo.
+ `target_output_location`: O nome da coluna no conjunto de dados de referência que contém o valor verdadeiro a ser comparado com o valor previsto contido em `model_output_location`. Exigido somente para conhecimento fatual, precisão e robustez semântica. Para conhecimento fatual, cada linha dessa coluna deve conter todas as respostas possíveis separadas por um delimitador. Por exemplo, se as respostas para uma pergunta forem [“Reino Unido”, “Inglaterra”], a coluna deverá conter “Reino UnidoInglaterra”. A predição de modelo estará correta se contiver qualquer uma das respostas separadas pelo delimitador.
+ `category_location`: O nome da coluna que contém o nome de uma categoria. Se você fornecer um valor para `category_location`, as pontuações serão agregadas e relatadas para cada categoria.
+ `sent_more_input_location`: O nome da coluna que contém o prompt com mais desvio. Obrigatório somente para estereotipagem de prompt. Evita preconceitos inconscientes. Para exemplos de desvio, consulte o [conjunto de dados CrowS-Pairs](https://paperswithcode.com/dataset/crows-pairs).
+ `sent_less_input_location`: O nome da coluna que contém o prompt com menos desvio. Obrigatório somente para estereotipagem de prompt. Evita preconceitos inconscientes. Para exemplos de desvio, consulte o [conjunto de dados CrowS-Pairs](https://paperswithcode.com/dataset/crows-pairs).
+ `sent_more_output_location`: (Opcional) O nome da coluna que contém uma probabilidade prevista de que a resposta gerada pelo seu modelo contenha mais desvio. Esse parâmetro é usado somente em tarefas de estereotipagem de prompt.
+ `sent_less_output_location`: (Opcional) O nome da coluna que contém uma probabilidade prevista de que a resposta gerada pelo seu modelo contenha menos desvio. Esse parâmetro é usado somente em tarefas de estereotipagem de prompt.
Se quiser adicionar um novo atributo que corresponda a uma coluna do conjunto de dados para a classe `DataConfig`, você deve adicionar o `suffix _location` ao final do nome do atributo.
## Usar um `ModelRunner` personalizado
Para avaliar um modelo personalizado, use uma classe de dados base para configurar seu modelo e criar um `ModelRunner` personalizado. Em seguida, você pode usar o `ModelRunner` para avaliar qualquer modelo de linguagem. Use as etapas a seguir para definir a configuração do modelo, criar um `ModelRunner` personalizado e realizar testes.
A interface do `ModelRunner` tem um método abstrato, conforme mostrado a seguir:
```
def predict(self, prompt: str) → Tuple[Optional[str], Optional[float]]
```
Esse método recebe um prompt como entrada de string e retorna uma tupla contendo uma resposta de texto do modelo e uma probabilidade de log de entrada. Cada `ModelRunner` deve implementar um método `predict`.
**Crie um `ModelRunner` personalizado**
1. Defina uma configuração de modelo.
O seguinte exemplo de código mostra como aplicar um decorador `dataclass` a uma classe `HFModelConfig` personalizada para que você possa definir uma configuração de modelo para um modelo **Hugging Face**:
```
from dataclasses import dataclass
@dataclass
class HFModelConfig:
model_name: str
max_new_tokens: int
seed: int = 0
remove_prompt_from_generated_text: bool = True
```
No exemplo de código anterior, aplica-se o seguinte:
+ O parâmetro `max_new_tokens` é usado para limitar o comprimento da resposta limitando o número de tokens retornados por um LLM. O tipo de modelo é definido passando um valor para `model_name` quando a classe é instanciada. Neste exemplo, o nome do modelo é definido como `gpt2`, conforme mostrado no final desta seção. O parâmetro `max_new_tokens` é uma opção para configurar estratégias de geração de texto usando uma configuração de modelo `gpt2` para um modelo OpenAI GPT pré-treinado. Consulte [AutoConfig](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html)outros tipos de modelo.
+ Se o parâmetro `remove_prompt_from_generated_text` estiver definido como `True`, a resposta gerada não conterá o prompt de origem enviado na solicitação.
Para outros parâmetros de geração de texto, consulte a [Hugging Facedocumentação](https://huggingface.co/docs/transformers/v4.34.1/en/main_classes/text_generation#transformers.GenerationConfig) do GenerationConfig.
1. Crie um `ModelRunner` personalizado e implemente um método de previsão. O exemplo de código a seguir mostra como criar um `ModelRunner` personalizado para um modelo Hugging Face usando a classe `HFModelConfig` criada no exemplo de código anterior.
```
from typing import Tuple, Optional
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from fmeval.model_runners.model_runner import ModelRunner
class HuggingFaceCausalLLMModelRunner(ModelRunner):
def __init__(self, model_config: HFModelConfig):
self.config = model_config
self.model = AutoModelForCausalLM.from_pretrained(self.config.model_name)
self.tokenizer = AutoTokenizer.from_pretrained(self.config.model_name)
def predict(self, prompt: str) -> Tuple[Optional[str], Optional[float]]:
input_ids = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
generations = self.model.generate(
**input_ids,
max_new_tokens=self.config.max_new_tokens,
pad_token_id=self.tokenizer.eos_token_id,
)
generation_contains_input = (
input_ids["input_ids"][0] == generations[0][: input_ids["input_ids"].shape[1]]
).all()
if self.config.remove_prompt_from_generated_text and not generation_contains_input:
warnings.warn(
"Your model does not return the prompt as part of its generations. "
"`remove_prompt_from_generated_text` does nothing."
)
if self.config.remove_prompt_from_generated_text and generation_contains_input:
output = self.tokenizer.batch_decode(generations[:, input_ids["input_ids"].shape[1] :])[0]
else:
output = self.tokenizer.batch_decode(generations, skip_special_tokens=True)[0]
with torch.inference_mode():
input_ids = self.tokenizer(self.tokenizer.bos_token + prompt, return_tensors="pt")["input_ids"]
model_output = self.model(input_ids, labels=input_ids)
probability = -model_output[0].item()
return output, probability
```
O código anterior usa uma `HuggingFaceCausalLLMModelRunner` classe personalizada que herda as propriedades da FMEval `ModelRunner` classe. A classe personalizada contém um construtor e uma definição para uma função de previsão, que retorna um `Tuple`.
Para ver mais exemplos de `ModelRunner`, consulte a seção [model\_runner](https://github.com/aws/fmeval/tree/main/src/fmeval/model_runners) da biblioteca `fmeval`.
O construtor `HuggingFaceCausalLLMModelRunner` contém as seguintes definições:
+ A configuração está definida como `HFModelConfig`, mostrada no início desta seção.
+ O modelo é definido como um modelo pré-treinado da [classe automática](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html) do Hugging Face, o que é especificado usando o parâmetro model\_name na instanciação.
+ O tokenizador é definido para uma classe da [biblioteca de tokenizadores do Hugging Face](https://huggingface.co/docs/transformers/model_doc/auto#transformers.AutoTokenizer) que corresponde ao modelo pré-treinado especificado por `model_name`.
O método `predict` na classe `HuggingFaceCausalLLMModelRunner` usa as seguintes definições:
+ `input_ids`: Uma variável que contém entradas para seu modelo. O modelo gera a entrada da seguinte forma:
+ A `tokenizer` Converte a solicitação contida `prompt` em identificadores de token ()IDs. Esses tokens IDs, que são valores numéricos que representam um token específico (palavra, subpalavra ou caractere), podem ser usados diretamente pelo seu modelo como entrada. O token IDs é retornado como objetos PyTorch tensores, conforme especificado por`return_tensors="pt"`. Para outros tipos de tensores de retorno, consulte a documentação do Hugging Face para [apply\_chat\_template](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.PreTrainedTokenizer.apply_chat_template).
+ IDs Os tokens são enviados para um dispositivo onde o modelo está localizado para que possam ser usados pelo modelo.
+ `generations`: uma variável que contém a resposta gerada pelo LLM. A função de geração do modelo usa as seguintes entradas para gerar a resposta:
+ O `input_ids` da etapa anterior.
+ O parâmetro `max_new_tokens` especificado em `HFModelConfig`.
+ Um `pad_token_id` adiciona um token de fim de frase (eos) à resposta. Para outros tokens que você pode usar, consulte a Hugging Face documentação do [PreTrainedTokenizer](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.PreTrainedTokenizer).
+ `generation_contains_input`: Uma variável booleana que retorna `True` quando a resposta gerada inclui o prompt de entrada nela e, `False`, caso contrário. O valor de retorno é calculado usando uma comparação de elemento entre os itens a seguir.
+ Todo o token IDs no prompt de entrada que está contido em`input_ids["input_ids"][0]`.
+ O início do conteúdo gerado que está contido em `generations[0][: input_ids["input_ids"].shape[1]]`.
O método `predict` retornará um aviso se você direcionou o LLM para `remove_prompt_from_generated_text` em sua configuração, mas a resposta gerada não contiver o prompt de entrada.
A saída do `predict` método contém uma string retornada pelo `batch_decode` método, que converte o token IDs retornado na resposta em texto legível por humanos. Se você especificou `remove_prompt_from_generated_text` como `True`, o prompt de entrada será removido do texto gerado. Se você especificou `remove_prompt_from_generated_text` como `False`, o texto gerado será retornado sem nenhum token especial incluído no dicionário `special_token_dict`, conforme especificado por `skip_special_tokens=True`.
1. Teste seu `ModelRunner`. Envie uma solicitação de amostra para seu modelo.
O seguinte exemplo mostra como testar um modelo usando o modelo pré-treinado `gpt2` da classe `AutoConfig` do Hugging Face:
```
hf_config = HFModelConfig(model_name="gpt2", max_new_tokens=32)
model = HuggingFaceCausalLLMModelRunner(model_config=hf_config)
```
No exemplo de código anterior, `model_name` especifica o nome do modelo pré-treinado. A classe `HFModelConfig` é instanciada como hf\_config com um valor para o parâmetro `max_new_tokens` e usada para inicializar o `ModelRunner`.
Se você quiser usar outro modelo pré-treinadoHugging Face, escolha um `pretrained_model_name_or_path` `from_pretrained` abaixo [AutoClass](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html).
Por fim, teste seu `ModelRunner`. Envie uma solicitação de amostra para o seu modelo conforme mostrado no código de seguinte exemplo:
```
model_output = model.predict("London is the capital of?")[0]
print(model_output)
eval_algo.evaluate_sample()
```