Personalize seu fluxo de trabalho usando a fmeval biblioteca

Crie um personalizado ModelRunner

1. Defina uma configuração de modelo.

   O exemplo de código a seguir mostra como aplicar um dataclass decorador a uma HFModelConfig 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 para model_name quando a classe é instanciada. Neste exemplo, o nome do modelo é definido comogpt2, 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 gpt2 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.

2. 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 personalizado ModelRunner para um Hugging Face modelo usando a HFModelConfig 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 FMEval ModelRunner 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_runner da biblioteca. fmeval

   O HuggingFaceCausalLLMModelRunner construtor contém as seguintes definições:

   • A configuração está definida comoHFModelConfig, 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 na HuggingFaceCausalLLMModelRunner 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 contida prompt 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_idA 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 retorna True quando a resposta gerada inclui o prompt de entrada em sua resposta e de False 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 eminput_ids["input_ids"][0].

     • O início do conteúdo gerado que está contido emgenerations[0][: input_ids["input_ids"].shape[1]].

     O predict método retornará um aviso se você direcionou o LLM to 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 comoTrue, o prompt de entrada será removido do texto gerado. Se você especificou remove_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.

3. Teste o seuModelRunner. 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 Face AutoConfigclasse:

   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 HFModelConfig classe é instanciada como hf_config com um valor para o parâmetro max_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 em from_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()