Personnalisez votre flux de travail à l'aide de la fmeval bibliothèque

Créez une personnalisation ModelRunner

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

   L'exemple de code suivant montre comment appliquer un dataclass décorateur à une HFModelConfig classe personnalisée afin de définir une configuration de modèle pour un Hugging Facemodèle :

   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 règles suivantes 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 unLLM. Le type de modèle est défini en transmettant une valeur pour le model_name moment où la classe est instanciée. Dans cet exemple, le nom du modèle est défini surgpt2, 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 gpt2 modèle pour un modèle GPT OpenAI pré-entraîné. Voir AutoConfigpour les autres types de modèles.

   • Si le paramètre remove_prompt_from_generated_text est défini surTrue, 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 Hugging Face documentation pour GenerationConfig.

2. Créez une méthode personnalisée ModelRunner et implémentez une méthode de prédiction. L'exemple de code suivant montre comment créer une personnalisation ModelRunner pour Hugging Face modèle utilisant la HFModelConfig classe 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 unTuple.

   Pour plus d'ModelRunnerexemples, consultez la section model_runner de la fmeval bibliothèque.

   Le HuggingFaceCausalLLMModelRunner constructeur contient les définitions suivantes :

   • La configuration est définie surHFModelConfig, définie au début de cette section.

   • Le modèle est réglé sur un modèle préentraîné à partir du Hugging Face Classe automatique spécifiée à l'aide du paramètre model_name lors de l'instanciation.

   • Le tokenizer est défini sur une classe du Hugging Face bibliothèque de tokenizer qui correspond au modèle préentraîné spécifié par. model_name

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

   • input_ids— Variable qui contient des entrées 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 jetonsIDs, 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. Le IDs jeton est renvoyé sous forme de PyTorch objets tenseurs, tels que spécifiés parreturn_tensors="pt". Pour les autres types de types de tenseurs de retour, consultez le Hugging Face documentation pour apply_chat_template.

     • IDsLes 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 votreLLM. La fonction generate du modèle utilise les entrées suivantes pour générer la réponse :

     • À input_ids partir de l'étape précédente.

     • Le paramètre max_new_tokens spécifié dansHFModelConfig.

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

   • generation_contains_input— Variable booléenne qui revient True lorsque la réponse générée inclut l'invite de saisie dans sa réponse, et False dans le cas contraire. La valeur de retour est calculée à l'aide d'une comparaison élément par élément entre les valeurs suivantes.

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

     • Début du contenu généré contenu dansgenerations[0][: input_ids["input_ids"].shape[1]].

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

     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 commeTrue, l'invite de saisie 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 dictionnairespecial_token_dict, comme indiqué parskip_special_tokens=True.

3. Testez votreModelRunner. Envoyez une demande d'échantillon à votre modèle.

   L'exemple suivant montre comment tester un modèle à l'aide du modèle gpt2 préentraîné issu du Hugging Face AutoConfigclasse :

   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 HFModelConfig classe est instanciée en tant que hf_config avec une valeur pour le paramètre et utilisée pour l'max_new_tokensinitialisation. ModelRunner

   Si vous souhaitez utiliser un autre modèle préentraîné de Hugging Face, choisissez un pretrained_model_name_or_path dans le champ from_pretrained ci-dessous AutoClass.

   Enfin, testez votreModelRunner. 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()