Personnalisation de votre flux de travail à l’aide de la bibliothèque fmeval

Création d’un élément ModelRunner personnalisé

1. Définissez une configuration de modèle.

   L’exemple de code suivant montre comment appliquer un décorateur dataclass à une classe HFModelConfig personnalisée afin de définir une configuration de modèle pour un modèle 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

   Dans l’exemple de code précédent, les points suivants s’appliquent :

   • Le paramètre max_new_tokens est utilisé pour limiter la longueur de la réponse en limitant le nombre de jetons renvoyés par un LLM. Le type de modèle est défini en transmettant une valeur pour model_name quand la classe est instanciée. Dans cet exemple, le nom du modèle est défini sur gpt2, comme indiqué à la fin de cette section. Le paramètre max_new_tokens est une option permettant de configurer des stratégies de génération de texte à l’aide d’une configuration de modèle gpt2 pour un modèle OpenAI GPT pré-entraîné. Voir AutoConfigpour les autres types de modèles.

   • Si le paramètre remove_prompt_from_generated_text est défini sur True, la réponse générée ne contiendra pas l’invite d’origine envoyée dans la demande.

   Pour les autres paramètres de génération de texte, consultez la Hugging Facedocumentation de GenerationConfig.

2. Créez un élément ModelRunner personnalisé et implémentez une méthode de prédiction. L’exemple de code suivant montre comment créer un élément ModelRunner personnalisé pour un modèle Hugging Face à l’aide de la classe HFModelConfig créée dans l’exemple de code précédent.

   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

   Le code précédent utilise une HuggingFaceCausalLLMModelRunner classe personnalisée qui hérite des propriétés de la FMEval ModelRunner classe. La classe personnalisée contient un constructeur et une définition pour une fonction de prédiction, qui renvoie un Tuple.

   Pour plus d’exemples ModelRunner, consultez la section model_runner de la bibliothèque fmeval.

   Le constructeur HuggingFaceCausalLLMModelRunner contient les définitions suivantes :

   • La configuration est configurée sur l’élément HFModelConfig, défini au début de cette section.

   • Le modèle est défini sur un modèle pré-entraîné à partir de la classe automatique Hugging Face qui est spécifiée à l’aide du paramètre model_name lors de l’instanciation.

   • Le créateur de jetons est défini sur une classe issue de la bibliothèque de créateurs de jetons Hugging Face qui correspond au modèle pré-entraîné spécifié par model_name.

   La méthode predict dans la classe HuggingFaceCausalLLMModelRunner utilise les définitions suivantes :

   • input_ids : variable qui contient l’entrée pour votre modèle. Le modèle génère l’entrée comme suit.

     • A tokenizer Convertit la demande contenue dans prompt en identifiants de jetons (IDs). Ces jetons IDs, qui sont des valeurs numériques représentant un jeton spécifique (mot, sous-mot ou caractère), peuvent être utilisés directement par votre modèle comme entrée. Les jetons IDs sont renvoyés sous forme d'objets PyTorch tenseurs, comme spécifié parreturn_tensors="pt". Pour les autres types de tenseurs de retour, consultez la documentation Hugging Face pour apply_chat_template.

     • IDs Les jetons sont envoyés à un appareil sur lequel se trouve le modèle afin qu'ils puissent être utilisés par le modèle.

   • generations : une variable qui contient la réponse générée par votre LLM. La fonction de génération du modèle utilise les entrées suivantes pour générer la réponse :

     • L’élément input_ids de l’étape précédente.

     • Le paramètre max_new_tokens spécifié dans HFModelConfig.

     • Un élément pad_token_id ajoute un jeton de fin de phrase (eos) à la réponse. Pour les autres jetons que vous pouvez utiliser, consultez la Hugging Face documentation de PreTrainedTokenizer.

   • generation_contains_input : une variable booléenne qui renvoie True lorsque la réponse générée inclut l’invite d’entrée dans sa réponse, et False dans le cas contraire. La valeur de retour est calculée à l’aide d’une comparaison par élément entre les éléments suivants.

     • Tous les jetons IDs de l'invite de saisie contenus dansinput_ids["input_ids"][0].

     • Le début du contenu généré contenu dans generations[0][: input_ids["input_ids"].shape[1]].

     La méthode predict renvoie un avertissement si vous avez dirigé le LLM vers remove_prompt_from_generated_text dans votre configuration mais la réponse générée ne contient pas l’invite d’entrée.

     La sortie de la predict méthode contient une chaîne renvoyée par la batch_decode méthode, qui convertit le jeton IDs renvoyé dans la réponse en texte lisible par l'homme. Si vous avez spécifié remove_prompt_from_generated_text comme True, l’invite d’entrée est supprimée du texte généré. Si vous avez spécifié remove_prompt_from_generated_text commeFalse, le texte généré sera renvoyé sans aucun jeton spécial que vous avez inclus dans le dictionnaire special_token_dict, comme spécifié par skip_special_tokens=True.

3. Testez votre élément ModelRunner. Envoyez un exemple de demande à votre modèle.

   L’exemple suivant montre comment tester un modèle à l’aide du modèle pré-entraîné gpt2 de la classe Hugging Face AutoConfig :

   hf_config = HFModelConfig(model_name="gpt2", max_new_tokens=32)
   model = HuggingFaceCausalLLMModelRunner(model_config=hf_config)

   Dans l’exemple de code précédent, model_name spécifie le nom du modèle pré-entraîné. La classe HFModelConfig est instanciée en tant que hf_config avec une valeur pour le paramètre max_new_tokens, et utilisée pour initialiser ModelRunner.

   Si vous souhaitez utiliser un autre modèle préentraîné parmiHugging Face, choisissez-en un pretrained_model_name_or_path ci-dessousfrom_pretrained. AutoClass

   Enfin, testez votre ModelRunner. Envoyez un exemple de demande à votre modèle, comme indiqué dans l’exemple de code suivant :

   model_output = model.predict("London is the capital of?")[0]
   print(model_output)
   eval_algo.evaluate_sample()