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 fmeval
biblioteca
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 personalizadoModelRunner
. Se você usar seu próprio conjunto de dados para avaliação, deverá configurar um DataConfig
objeto. A seção a seguir mostra como formatar seu conjunto de dados de entrada, personalizar um DataConfig
objeto para usar seu conjunto de dados personalizado e criar um personalizado. ModelRunner
Se quiser usar seu próprio conjunto de dados para avaliar seu modelo, você deve usar um DataConfig
objeto para especificar o dataset_name
e o dataset_uri
do conjunto de dados que você deseja avaliar. Se você usa um conjunto de dados incorporado, o DataConfig
objeto já está configurado como padrão para algoritmos de avaliação.
Você pode usar um conjunto de dados personalizado sempre que usar a evaluate
função. Você pode invocar evaluate
quantas vezes quiser para usar qualquer quantidade de conjuntos de dados que 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", )
A DataConfig
classe contém os seguintes parâmetros:
-
dataset_name
— O nome do conjunto de dados que você deseja usar para avaliar seuLLM.dataset_uri
— O caminho local ou identificador uniforme de recurso (URI) para a localização do seu conjunto de dados no S3. -
dataset_mime_type
— O formato dos dados de entrada que você deseja usar para avaliar seusLLM. A FMEval biblioteca pode suportarMIME_TYPE_JSON
tantoMIME_TYPE_JSONLINES
e. -
model_input_location
— (Opcional) O nome da coluna em seu conjunto de dados que contém as entradas ou solicitações 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 abertas de geração, toxicidade e precisão, especifique a coluna que contém a solicitação à 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 factual, 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 perturbe.
-
Para avaliações imediatas de estereotipagem, use o
sent_more_input_location
esent_less_input_location
em vez demodel_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 nelatarget_output_location
. Se você fornecermodel_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 real a ser comparado com o valor previsto contido nelemodel_output_location
. Exigido somente para conhecimento factual, precisão e robustez semântica. Para conhecimento factual, 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 Unido <OR>Inglaterra”. A previsão do modelo está 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 paracategory_location
, as pontuações serão agregadas e relatadas para cada categoria. -
sent_more_input_location
— O nome da coluna que contém um prompt com mais viés. Necessário somente para estereotipagem imediata. Evite preconceitos inconscientes. Para exemplos de viés, consulte o conjunto de dados Crows-pairs. -
sent_less_input_location
— O nome da coluna que contém um prompt com menos distorção. Necessário somente para estereotipagem imediata. Evite preconceitos inconscientes. Para exemplos de viés, consulte o conjunto de dados 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 viés. Esse parâmetro é usado somente em tarefas de estereotipagem imediata. -
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 viés. Esse parâmetro é usado somente em tarefas de estereotipagem imediata.
Se quiser adicionar um novo atributo que corresponda a uma coluna do conjunto de dados na DataConfig
classe, você deve adicionar o suffix
_location
ao final do nome do atributo.
Para avaliar um modelo personalizado, use uma classe de dados base para configurar seu modelo e criar um personalizadoModelRunner
. Em seguida, você pode usar isso ModelRunner
para avaliar qualquer modelo de linguagem. Use as etapas a seguir para definir uma configuração de modelo, criar uma personalizada ModelRunner
e testá-la.
A ModelRunner
interface tem um método abstrato da seguinte forma:
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 registro de entrada. Cada um ModelRunner
deve implementar um predict
método.
Crie um personalizado ModelRunner
-
Defina uma configuração de modelo.
O exemplo de código a seguir mostra como aplicar um
dataclass
decorador a umaHFModelConfig
classe personalizada para que você possa definir uma configuração de modelo para um Hugging Facemodelo: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, o seguinte se aplica:
-
O parâmetro
max_new_tokens
é usado para limitar o comprimento da resposta limitando o número de tokens retornados por umLLM. O tipo de modelo é definido passando um valor paramodel_name
quando a classe é instanciada. Neste exemplo, o nome do modelo é definido comogpt2
, conforme mostrado no final desta seção. O parâmetromax_new_tokens
é uma opção para configurar estratégias de geração de texto usando uma configuração degpt2
modelo para um modelo GPT OpenAI pré-treinado. Consulte AutoConfigoutros tipos de modelo. -
Se o parâmetro
remove_prompt_from_generated_text
estiver definido comoTrue
, a resposta gerada não conterá a solicitação de origem enviada na solicitação.
Para outros parâmetros de geração de texto, consulte o Hugging Face documentação para GenerationConfig
. -
-
Crie um método personalizado
ModelRunner
e implemente um método de previsão. O exemplo de código a seguir mostra como criar um personalizadoModelRunner
para um Hugging Face modelo usando aHFModelConfig
classe 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 FMEvalModelRunner
classe. A classe personalizada contém um construtor e uma definição para uma função de previsão, que retorna a.Tuple
Para ver mais
ModelRunner
exemplos, consulte a seção model_runnerda biblioteca. fmeval
O
HuggingFaceCausalLLMModelRunner
construtor contém as seguintes definições:-
A configuração está definida como
HFModelConfig
, definida no início desta seção. -
O modelo é definido como um modelo pré-treinado do Hugging Face Classe automática
que é especificada usando o parâmetro model_name na instanciação. -
O tokenizador é definido como uma classe do Hugging Face biblioteca tokenizer
que corresponde ao modelo pré-treinado especificado por. model_name
O
predict
método naHuggingFaceCausalLLMModelRunner
classe 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 contidaprompt
em identificadores de token ()IDs. Esses tokensIDs, 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 um PyTorch objetos tensores, conforme especificado porreturn_tensors="pt"
. Para outros tipos de tensores de retorno, consulte Hugging Face documentação para apply_chat_template. -
IDsOs 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 seuLLM. A função generate do modelo usa as seguintes entradas para gerar a resposta:-
O
input_ids
da etapa anterior. -
O parâmetro
max_new_tokens
especificado emHFModelConfig
. -
pad_token_id
A adiciona um token de fim de frase (eos) à resposta. Para outros tokens que você pode usar, consulte o Hugging Face documentação para PreTrainedTokenizer.
-
-
generation_contains_input
— Uma variável booleana que retornaTrue
quando a resposta gerada inclui o prompt de entrada em sua resposta e deFalse
outra forma. O valor de retorno é calculado usando uma comparação elemento a 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
predict
método retornará um aviso se você direcionou o LLM toremove_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 pelobatch_decode
método, que converte o token IDs retornado na resposta em texto legível por humanos. Se você especificouremove_prompt_from_generated_text
comoTrue
, o prompt de entrada será removido do texto gerado. Se você especificouremove_prompt_from_generated_text
comoFalse
, o texto gerado será retornado sem nenhum símbolo especial incluído no dicionáriospecial_token_dict
, conforme especificado porskip_special_tokens=True
. -
-
-
Teste o seu
ModelRunner
. Envie uma solicitação de amostra para seu modelo.O exemplo a seguir mostra como testar um modelo usando o modelo
gpt2
pré-treinado do Hugging FaceAutoConfig
classe: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. AHFModelConfig
classe é instanciada como hf_config com um valor para o parâmetromax_new_tokens
e usada para inicializar.ModelRunner
Se você quiser usar outro modelo pré-treinado da Hugging Face, escolha um
pretrained_model_name_or_path
emfrom_pretrained
baixo AutoClass. Por fim, teste seu.
ModelRunner
Envie uma solicitação de amostra para seu modelo, conforme mostrado no exemplo de código a seguir:model_output = model.predict("London is the capital of?")[0] print(model_output) eval_algo.evaluate_sample()