Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Passen Sie Ihren Arbeitsablauf mithilfe der `fmeval` Bibliothek an
Sie können Ihre Modellevaluierung so anpassen, dass sie ein Modell berücksichtigt, das kein Amazon Bedrock-Modell ist, oder einen benutzerdefinierten Workflow für die Bewertung verwenden. JumpStart Wenn Sie Ihr eigenes Modell verwenden, müssen Sie ein benutzerdefiniertes Modell erstellen. `ModelRunner` Wenn Sie Ihren eigenen Datensatz für die Auswertung verwenden, müssen Sie ein `DataConfig` Objekt konfigurieren. Im folgenden Abschnitt wird gezeigt, wie Sie Ihren Eingabedatensatz formatieren, ein `DataConfig` Objekt so anpassen, dass er Ihren benutzerdefinierten Datensatz verwendet, und einen benutzerdefinierten Datensatz erstellen`ModelRunner`.
## Verwenden Sie einen benutzerdefinierten Eingabedatensatz
Wenn Sie Ihren eigenen Datensatz verwenden möchten, um Ihr Modell auszuwerten, müssen Sie ein `DataConfig` Objekt verwenden, um das `dataset_name` und das `dataset_uri` des Datensatzes anzugeben, den Sie auswerten möchten. Wenn Sie einen integrierten Datensatz verwenden, ist das `DataConfig` Objekt bereits als Standard für Bewertungsalgorithmen konfiguriert.
Sie können jedes Mal, wenn Sie die `evaluate` Funktion verwenden, einen benutzerdefinierten Datensatz verwenden. Sie können `evaluate` beliebig oft aufrufen, um eine beliebige Anzahl von Datensätzen zu verwenden.
Konfigurieren Sie einen benutzerdefinierten Datensatz mit Ihrer Modellanforderung, die in der Fragenspalte angegeben ist, und der Zielantwort, die in der Spaltenantwort angegeben ist, wie folgt:
```
from fmeval.data_loaders.data_config import DataConfig
from fmeval.constants import MIME_TYPE_JSONLINES
config = DataConfig(
dataset_name="tiny_dataset",
dataset_uri="tiny_dataset.jsonl",
dataset_mime_type=MIME_TYPE_JSONLINES,
model_input_location="question",
target_output_location="answer",
)
```
Die `DataConfig`-Klasse enthält die folgenden Parameter:
+ `dataset_name` – Der Name des Datensatzes, den Sie zur Bewertung Ihres LLM verwenden möchten.
`dataset_uri` – Der lokale Pfad oder der Uniform Resource Identifier (URI) zum S3-Speicherort Ihres Datensatzes.
+ `dataset_mime_type` – Das Profil, das Sie für die Bewertung Ihres LLM verwenden möchten. Die FMEval Bibliothek kann sowohl als auch `MIME_TYPE_JSON` unterstützen. `MIME_TYPE_JSONLINES`
+ `model_input_location` – (Optional) Der Name der Spalte in Ihrem Datensatz, die die Modelleingaben oder Eingabeaufforderungen enthält, die Sie auswerten möchten.
Verwenden Sie eine`model_input_location`, die den Namen Ihrer Spalte angibt. Die Spalte muss die folgenden Werte enthalten, die den folgenden zugehörigen Aufgaben entsprechen:
+ Geben Sie **für Generierungs** -, **Toxizitäts** - und **Genauigkeitsbeurteilungen** die Spalte an, die die **Aufforderung** enthält, auf die Ihr Modell reagieren soll.
+ Geben Sie für eine Aufgabe zur **Beantwortung von Fragen** die Spalte an, die die **Frage** enthält, auf die Ihr Modell eine Antwort generieren soll.
+ Geben Sie für eine **Aufgabe zur Textzusammenfassung** den Namen der Spalte an, die den **Text** enthält, den Ihr Modell zusammenfassen soll.
+ Geben Sie für eine **Klassifizierungsaufgabe** den Namen der Spalte an, die den **Text** enthält, den Ihr Modell klassifizieren soll.
+ Geben Sie für Bewertungen von **Faktenwissen** den Namen der Spalte an, die die **Frage** enthält, auf die das Modell die Antwort vorhersagen soll.
+ Geben Sie für Bewertungen der **semantischen Robustheit** den Namen der Spalte an, die die **Eingabe** enthält, die Ihr Modell stören soll.
+ Verwenden **Sie für schnelle Stereotypauswertungen** das `sent_more_input_location` und ` sent_less_input_location` anstelle von`model_input_location`, wie in den folgenden Parametern gezeigt.
+ `model_output_location` – (Optional) Der Name der Spalte in Ihrem Datensatz, die die prognostizierte Ausgabe enthält, die Sie mit der Referenzausgabe vergleichen möchten, die in enthalten ist. `target_output_location` Wenn Sie angeben`model_output_location`, FMEval wird keine Anfrage an Ihr Modell gesendet, um Rückschlüsse zu ziehen. Stattdessen verwendet es die in der angegebenen Spalte enthaltene Ausgabe, um Ihr Modell auszuwerten.
+ `target_output_location` – Der Name der Spalte im Referenzdatensatz, die den wahren Wert enthält, der mit dem vorhergesagten Wert verglichen werden soll, der in enthalten ist`model_output_location`. Nur für Faktenwissen, Genauigkeit und semantische Robustheit erforderlich. Für Faktenwissen sollte jede Zeile in dieser Spalte alle möglichen Antworten enthalten, die durch ein Trennzeichen getrennt sind. Lauten die Antworten auf eine Frage beispielsweise [„UK“, „England“], dann sollte die Spalte „UK England“ enthalten. Die Modellvorhersage ist korrekt, wenn sie eine der Antworten enthält, die durch das Trennzeichen getrennt sind.
+ `category_location` – Der Name der Spalte, in der der Name einer Kategorie gespeichert ist. Wenn Sie einen Wert für angeben`category_location`, werden die Ergebnisse aggregiert und für jede Kategorie gemeldet.
+ `sent_more_input_location` – Der Name der Spalte, in der eine Prompt mit mehr Voreingenommenheit gespeichert ist. Nur für die Stereotypisierung von Aufforderungen erforderlich. Vermeiden Sie unbewusste Vorurteile. Beispiele für Verzerrungen finden Sie im Datensatz [Crows-pairs](https://paperswithcode.com/dataset/crows-pairs).
+ `sent_less_input_location` – Der Name der Spalte, in der eine weniger voreingenommene Aufforderung gespeichert ist. Nur für die Stereotypisierung von Aufforderungen erforderlich. Vermeiden Sie unbewusste Vorurteile. Beispiele für Verzerrungen finden Sie im Datensatz [Crows-pairs](https://paperswithcode.com/dataset/crows-pairs).
+ `sent_more_output_location` – (Optional) Der Name der Spalte, die die prognostizierte Wahrscheinlichkeit enthält, dass die von Ihrem Modell generierte Antwortvariable mehr systematische Abweichungen enthält. Dieser Parameter wird nur bei Aufgaben zur Stereotypisierung von Eingabeaufforderungen verwendet.
+ `sent_less_output_location` – (Optional) Der Name der Spalte, die die prognostizierte Wahrscheinlichkeit enthält, dass die von Ihrem Modell generierte Antwortvariable weniger systematische Messabweichung enthält. Dieser Parameter wird nur bei Aufgaben zur Stereotypisierung von Eingabeaufforderungen verwendet.
Wenn Sie der `DataConfig` Klasse ein neues Attribut hinzufügen möchten, das einer Datensatzspalte entspricht, müssen Sie das `suffix _location` am Ende des Attributnamens hinzufügen.
## Verwenden Sie ein benutzerdefiniertes `ModelRunner`
Um ein benutzerdefiniertes Modell auszuwerten, verwenden Sie eine Basisdatenklasse, um Ihr Modell zu konfigurieren und ein benutzerdefiniertes Modell zu erstellen`ModelRunner`. Anschließend können Sie `ModelRunner` damit jedes beliebige Sprachmodell evaluieren. Verwenden Sie die folgenden Schritte, um eine Modellkonfiguration zu definieren, eine benutzerdefinierte `ModelRunner` zu erstellen und sie zu testen.
Die `ModelRunner` Schnittstelle hat eine abstrakte Methode wie folgt:
```
def predict(self, prompt: str) → Tuple[Optional[str], Optional[float]]
```
Diese Methode akzeptiert eine Eingabeaufforderung als Zeichenketteneingabe und gibt ein Tuple zurück, das eine Modelltextantwort und eine Eingabe-Log-Wahrscheinlichkeit enthält. Jeder `ModelRunner` muss eine `predict` Methode implementieren.
**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 ein **Hugging Face**Modell definieren können:
```
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 bei der Instanziierung der Klasse ein Wert für `model_name` übergeben wird. In diesem Beispiel ist der Modellname auf gesetzt`gpt2`, 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. [AutoConfig](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html)Weitere Modelltypen finden Sie unter.
+ Wenn der Parameter auf gesetzt `remove_prompt_from_generated_text` ist`True`, enthält die generierte Antwort nicht die ursprüngliche Aufforderung, die in der Anfrage gesendet wurde.
Weitere Parameter für die Textgenerierung finden Sie in der [Hugging FaceDokumentation für GenerationConfig](https://huggingface.co/docs/transformers/v4.34.1/en/main_classes/text_generation#transformers.GenerationConfig).
1. Erstellen Sie eine benutzerdefinierte Methode `ModelRunner` und implementieren Sie eine Vorhersagemethode. Das folgende Codebeispiel zeigt, wie Sie mithilfe der im vorherigen Codebeispiel erstellten `HFModelConfig` Klasse einen benutzerdefinierten Code `ModelRunner` für ein Hugging Face Modell erstellen.
```
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\$1runner](https://github.com/aws/fmeval/tree/main/src/fmeval/model_runners) der Bibliothek. `fmeval`
Der `HuggingFaceCausalLLMModelRunner` Konstruktor enthält die folgenden Definitionen:
+ Die Konfiguration ist auf eingestellt`HFModelConfig`, wie am Anfang dieses Abschnitts definiert.
+ Das Modell wird auf ein vortrainiertes Modell aus der Hugging Face[Auto-Klasse](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html) gesetzt, das bei der Instanziierung mit dem Parameter model\$1name angegeben wird.
+ Der Tokenizer ist auf eine Klasse aus der Tokenizer-Bibliothek festgelegt, die dem von angegebenen [Hugging Facevortrainierten Modell entspricht](https://huggingface.co/docs/transformers/model_doc/auto#transformers.AutoTokenizer). `model_name`
Die Methode `predict` in der Klasse `HuggingFaceCausalLLMModelRunner` 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 als PyTorch Tensorobjekt zurückgegeben, wie von angegeben. `return_tensors="pt"` [Weitere Arten von Rückgabe-Tensortypen finden Sie in der Hugging Face Dokumentation zu apply\$1chat\$1template.](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.PreTrainedTokenizer.apply_chat_template)
+ Token IDs werden an ein Gerät gesendet, auf dem sich das Modell befindet, sodass 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:
+ Das `input_ids` aus dem vorherigen Schritt.
+ Der in `max_new_tokens` angegebene Parameter`HFModelConfig`.
+ A `pad_token_id` fügt der Antwort ein Satzende-Token (EOS) hinzu. Weitere Token, die Sie verwenden können, finden Sie in der Hugging Face Dokumentation zu [PreTrainedTokenizer](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.PreTrainedTokenizer).
+ `generation_contains_input` – Eine boolesche Variable, die zurückkehrt, `True` wenn die generierte Antwort die Eingabeaufforderung in ihrer Antwort enthält, und andernfalls. `False` 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 ist`generations[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 für Menschen lesbaren Text umwandelt. Wenn Sie `remove_prompt_from_generated_text` als angegeben haben`True`, wird die Eingabeaufforderung aus dem generierten Text entfernt. Wenn Sie `remove_prompt_from_generated_text` als angegeben haben`False`, wird der generierte Text ohne spezielle Tokens zurückgegeben, die Sie in das Wörterbuch aufgenommen haben`special_token_dict`, wie von angegeben`skip_special_tokens=True`.
1. Testen Sie Ihre`ModelRunner`. Senden Sie eine Musteranfrage an Ihr Modell.
Das folgende Beispiel zeigt, wie man ein Modell mit Hilfe des `gpt2` vortrainierten Modells aus der Hugging Face `AutoConfig` Klasse testet:
```
hf_config = HFModelConfig(model_name="gpt2", max_new_tokens=32)
model = HuggingFaceCausalLLMModelRunner(model_config=hf_config)
```
`model_name`Gibt im vorherigen Codebeispiel den Namen des vortrainierten Modells an. Die `HFModelConfig`-Klasse wird als hf\$1config mit einem Wert für den `max_new_tokens`-Parameter instanziiert und zur Initialisierung von `ModelRunner` verwendet.
Wenn Sie ein anderes vortrainiertes Modell von verwenden möchtenHugging Face, wählen Sie `pretrained_model_name_or_path` `from_pretrained` unter [AutoClass](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html)ein.
Testen Sie abschließend Ihre. `ModelRunner` Senden Sie eine Musteranforderung an Ihr Modell wie im folgenden Beispielcode gezeigt zu umschließen:
```
model_output = model.predict("London is the capital of?")[0]
print(model_output)
eval_algo.evaluate_sample()
```