Passen Sie Ihren Arbeitsablauf mithilfe der fmeval Bibliothek an

Erstellen Sie ein benutzerdefiniertes ModelRunner

1. Definieren Sie eine Modellkonfiguration.

   Das folgende Codebeispiel zeigt, wie Sie einen dataclass Decorator auf eine benutzerdefinierte HFModelConfig Klasse anwenden, sodass Sie eine Modellkonfiguration für eine definieren können Hugging FaceModell:

   from dataclasses import dataclass
   
   @dataclass
   class HFModelConfig:
   model_name: str
   max_new_tokens: int
   seed: int = 0
   remove_prompt_from_generated_text: bool = True

   Im vorherigen Codebeispiel gilt Folgendes:

   • Der Parameter max_new_tokens wird verwendet, um die Länge der Antwort zu begrenzen, indem die Anzahl der von einem LLM zurückgegebenen Token begrenzt wird. Der Modelltyp wird festgelegt, indem ein Wert für die model_name Instanziierung der Klasse übergeben wird. In diesem Beispiel ist der Modellname auf gesetztgpt2, wie am Ende dieses Abschnitts gezeigt. Der Parameter max_new_tokens ist eine Option zur Konfiguration von Textgenerierungsstrategien mithilfe einer gpt2 Modellkonfiguration für ein vortrainiertes OpenAI-GPT-Modell. Weitere Modelltypen AutoConfigfinden Sie unter.

   • Wenn der Parameter auf gesetzt remove_prompt_from_generated_text istTrue, enthält die generierte Antwort nicht die ursprüngliche Aufforderung, die in der Anfrage gesendet wurde.

   Weitere Parameter für die Textgenerierung finden Sie im Hugging Face Dokumentation für GenerationConfig.

2. Erstellen Sie eine benutzerdefinierte Methode ModelRunner und implementieren Sie eine Vorhersagemethode. Das folgende Codebeispiel zeigt, wie Sie einen benutzerdefinierten Code ModelRunner für ein erstellen Hugging Face Modell unter Verwendung der HFModelConfig Klasse, die im vorherigen Codebeispiel erstellt wurde.

   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

   Der vorherige Code verwendet eine benutzerdefinierte HuggingFaceCausalLLMModelRunner Klasse, die Eigenschaften von der FMEval ModelRunner Klasse erbt. Die benutzerdefinierte Klasse enthält einen Konstruktor und eine Definition für eine Vorhersagefunktion, die a zurückgibt. Tuple

   Weitere ModelRunner Beispiele finden Sie im Abschnitt model_runner der Bibliothek. fmeval

   Der HuggingFaceCausalLLMModelRunner Konstruktor enthält die folgenden Definitionen:

   • Die Konfiguration ist auf eingestelltHFModelConfig, wie am Anfang dieses Abschnitts definiert.

   • Das Modell ist auf ein vortrainiertes Modell aus dem eingestellt Hugging Face Auto-Klasse, die bei der Instanziierung mit dem Parameter model_name angegeben wird.

   • Der Tokenizer ist auf eine Klasse aus dem gesetzt Hugging Face Tokenizer-Bibliothek, die dem vortrainierten Modell entspricht, das von spezifiziert ist. model_name

   Die predict Methode in der HuggingFaceCausalLLMModelRunner Klasse verwendet die folgenden Definitionen:

   • input_ids— Eine Variable, die Eingaben für Ihr Modell enthält. Das Modell generiert die Eingabe wie folgt.

     • A tokenizer Konvertiert die in enthaltene Anfrage prompt in Token-Identifikatoren (IDs). Diese Token IDs, bei denen es sich um numerische Werte handelt, die ein bestimmtes Token (Wort, Unterwort oder Zeichen) darstellen, können direkt von Ihrem Modell als Eingabe verwendet werden. Das Token IDs wird zurückgegeben als PyTorch Tensor-Objekte, wie von return_tensors="pt" spezifiziert. Andere Arten von Rückgabe-Tensortypen finden Sie in Hugging Face Dokumentation für apply_chat_template.

     • Token IDs werden an ein Gerät gesendet, auf dem sich das Modell befindet, damit sie vom Modell verwendet werden können.

   • generations— Eine Variable, die die von Ihrem LLM generierte Antwort enthält. Die Generierungsfunktion des Modells verwendet die folgenden Eingaben, um die Antwort zu generieren:

     • Die input_ids aus dem vorherigen Schritt.

     • Der in max_new_tokens angegebene ParameterHFModelConfig.

     • A pad_token_id fügt der Antwort ein Satzende-Token (EOS) hinzu. Weitere Tokens, die Sie verwenden können, finden Sie im Hugging Face Dokumentation für PreTrainedTokenizer.

   • generation_contains_input— Eine boolesche Variable, die zurückkehrt, True wenn die generierte Antwort die Eingabeaufforderung in ihrer Antwort enthält, und False andernfalls. Der Rückgabewert wird anhand eines elementweisen Vergleichs der folgenden Werte berechnet.

     • Alle Token IDs in der Eingabeaufforderung, die in enthalten sind. input_ids["input_ids"][0]

     • Der Anfang des generierten Inhalts, der in enthalten istgenerations[0][: input_ids["input_ids"].shape[1]].

     Die predict Methode gibt eine Warnung zurück, wenn Sie das LLM remove_prompt_from_generated_text in Ihrer Konfiguration darauf hingewiesen haben, die generierte Antwort jedoch nicht die Eingabeaufforderung enthält.

     Die Ausgabe der predict Methode enthält eine von der Methode zurückgegebene Zeichenfolge, die das batch_decode in der Antwort IDs zurückgegebene Token in menschenlesbaren Text umwandelt. Wenn Sie remove_prompt_from_generated_text als angegeben habenTrue, wird die Eingabeaufforderung aus dem generierten Text entfernt. Wenn Sie remove_prompt_from_generated_text als angegeben habenFalse, wird der generierte Text ohne spezielle Tokens zurückgegeben, die Sie in das Wörterbuch aufgenommen habenspecial_token_dict, wie von angegebenskip_special_tokens=True.

3. Testen Sie IhreModelRunner. Senden Sie eine Musteranfrage an Ihr Modell.

   Das folgende Beispiel zeigt, wie Sie ein Modell mit dem gpt2 vortrainierten Modell aus dem testen Hugging Face AutoConfigKlasse:

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

   model_nameGibt im vorherigen Codebeispiel den Namen des vortrainierten Modells an. Die HFModelConfig Klasse wird als hf_config mit einem Wert für den Parameter instanziiert und zur Initialisierung verwendetmax_new_tokens. ModelRunner

   Wenn Sie ein anderes vortrainiertes Modell von verwenden möchten Hugging Face, wählen Sie einen pretrained_model_name_or_path Wert from_pretrained unter AutoClass.

   Testen Sie zum Schluss IhreModelRunner. Senden Sie eine Musteranfrage an Ihr Modell, wie im folgenden Codebeispiel gezeigt:

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