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

Vous pouvez personnaliser l'évaluation de votre modèle pour autoriser un modèle autre qu'un modèle Amazon Bedrock JumpStart ou utiliser un flux de travail personnalisé pour l'évaluation. Si vous utilisez votre propre modèle, vous devez créer un modèle personnaliséModelRunner. Si vous utilisez votre propre ensemble de données pour l'évaluation, vous devez configurer un DataConfig objet. La section suivante explique comment formater votre jeu de données en entrée, personnaliser un DataConfig objet pour utiliser votre ensemble de données personnalisé et créer un ensemble de données personnaliséModelRunner.

Si vous souhaitez utiliser votre propre jeu de données pour évaluer votre modèle, vous devez utiliser un DataConfig objet pour spécifier le dataset_name et le dataset_uri nom du jeu de données que vous souhaitez évaluer. Si vous utilisez un ensemble de données intégré, l'DataConfigobjet est déjà configuré par défaut pour les algorithmes d'évaluation.

Vous pouvez utiliser un ensemble de données personnalisé chaque fois que vous utilisez la evaluate fonction. Vous pouvez appeler autant evaluate de fois que vous le souhaitez pour utiliser autant de jeux de données que vous le souhaitez.

Configurez un jeu de données personnalisé avec votre demande de modèle spécifiée dans la colonne des questions et la réponse cible spécifiée dans la réponse de la colonne, comme suit :


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",
)

La DataConfig classe contient les paramètres suivants :

dataset_name— Le nom de l'ensemble de données que vous souhaitez utiliser pour évaluer votreLLM.

dataset_uri— Le chemin local ou l'identifiant de ressource uniforme (URI) vers l'emplacement S3 de votre ensemble de données.
dataset_mime_type— Le format des données d'entrée que vous souhaitez utiliser pour évaluer votreLLM. La FMEval bibliothèque peut prendre en charge à la fois MIME_TYPE_JSON etMIME_TYPE_JSONLINES.
model_input_location— (Facultatif) Le nom de la colonne de votre jeu de données qui contient les entrées ou les instructions du modèle que vous souhaitez évaluer.

Utilisez un model_input_location qui indique le nom de votre colonne. La colonne doit contenir les valeurs suivantes correspondant aux tâches associées suivantes :
- Pour les évaluations de génération ouverte, de toxicité et de précision, spécifiez la colonne qui contient l'invite à laquelle votre modèle doit répondre.
- Pour une tâche de réponse à une question, spécifiez la colonne contenant la question à laquelle votre modèle doit générer une réponse.
- Pour une tâche de synthèse de texte, spécifiez le nom de la colonne contenant le texte que vous souhaitez que votre modèle récapitule.
- Pour une tâche de classification, spécifiez le nom de la colonne contenant le texte que vous souhaitez que votre modèle classe.
- Pour une évaluation des connaissances factuelles, spécifiez le nom de la colonne contenant la question à laquelle vous souhaitez que le modèle prédise la réponse.
- Pour les évaluations de robustesse sémantique, spécifiez le nom de la colonne contenant l'entrée que vous souhaitez que votre modèle perturbe.
- Pour une évaluation rapide des stéréotypes, utilisez le sent_more_input_location et sent_less_input_location au lieu demodel_input_location, comme indiqué dans les paramètres suivants.
model_output_location— (Facultatif) Le nom de la colonne de votre ensemble de données qui contient la sortie prévue que vous souhaitez comparer à la sortie de référence qui y est contenuetarget_output_location. Si vous le fournissezmodel_output_location, vous FMEval n'enverrez pas de demande d'inférence à votre modèle. Il utilise plutôt la sortie contenue dans la colonne spécifiée pour évaluer votre modèle.
target_output_location— Le nom de la colonne du jeu de données de référence qui contient la vraie valeur à comparer à la valeur prévue qui y est contenuemodel_output_location. Nécessaire uniquement pour les connaissances factuelles, la précision et la robustesse sémantique. Pour des informations factuelles, chaque ligne de cette colonne doit contenir toutes les réponses possibles séparées par un délimiteur. Par exemple, si les réponses à une question sont [« Royaume-Uni », « Angleterre »], la colonne doit contenir « Royaume-Uni <OR>Angleterre ». La prédiction du modèle est correcte si elle contient l'une des réponses séparées par le délimiteur.
category_location— Nom de la colonne contenant le nom d'une catégorie. Si vous fournissez une valeur pourcategory_location, les scores sont agrégés et présentés pour chaque catégorie.
sent_more_input_location— Nom de la colonne contenant une invite plus biaisée. Nécessaire uniquement pour un stéréotypage rapide. Évitez les préjugés inconscients. Pour des exemples de biais, consultez le jeu de données Crows-pairs.
sent_less_input_location— Le nom de la colonne contenant une invite moins biaisée. Nécessaire uniquement pour un stéréotypage rapide. Évitez les préjugés inconscients. Pour des exemples de biais, consultez le jeu de données Crows-pairs.
sent_more_output_location— (Facultatif) Le nom de la colonne qui contient une probabilité prédite que la réponse générée par votre modèle contienne le plus de biais. Ce paramètre est uniquement utilisé dans les tâches de stéréotypage rapide.
sent_less_output_location— (Facultatif) Nom de la colonne contenant une probabilité prédite que la réponse générée par votre modèle contienne moins de biais. Ce paramètre est uniquement utilisé dans les tâches de stéréotypage rapide.

Si vous souhaitez ajouter un nouvel attribut correspondant à une colonne de jeu de données dans la DataConfig classe, vous devez ajouter le suffix _location à la fin du nom de l'attribut.

Pour évaluer un modèle personnalisé, utilisez une classe de données de base pour configurer votre modèle et créer un modèle personnaliséModelRunner. Vous pouvez ensuite l'utiliser ModelRunner pour évaluer n'importe quel modèle de langage. Suivez les étapes ci-dessous pour définir une configuration de modèle, créer une configuration personnalisée ModelRunner et la tester.

L'ModelRunnerinterface possède une méthode abstraite comme suit :


def predict(self, prompt: str) → Tuple[Optional[str], Optional[float]]

Cette méthode prend une invite sous forme de chaîne d'entrée et renvoie un Tuple contenant une réponse textuelle modèle et un log de probabilité en entrée. Chacun ModelRunner doit implémenter une predict méthode.

Créez une personnalisation `ModelRunner`

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.
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 un 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].
  - Le début du contenu généré qui est 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.
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()
```

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Résultats du Job

Tutoriels pour ordinateurs

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

Créez une personnalisation ModelRunner

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

Créez une personnalisation `ModelRunner`