Personalize seu fluxo de trabalho usando a biblioteca fmeval

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 AutoConfigpara ver 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 do GenerationConfig.

2. 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 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 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 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 porreturn_tensors="pt". Para outros tipos de tensores de retorno, consulte a documentação do Hugging Face para 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.

   • 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 eminput_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.

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

   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()