`). L’algorithme de connaissances factuelles compare la réponse générée par votre modèle à une réponse connue. L’algorithme note la réponse comme étant correcte s’il génère un contenu séparé par le délimiteur dans la réponse. Si vous transmettez `None` comme `target_output_delimiter`, le modèle doit générer la même réponse que la réponse pour être noté comme correct. Enfin, appelez la méthode `evaluate` et transmettez-lui les paramètres que vous souhaitez.
Les connaissances factuelles renvoient une liste d’objets `EvalScore`. Ceux-ci contiennent des scores agrégés indiquant dans quelle mesure votre modèle est capable de coder les connaissances factuelles, comme décrit dans la section **Présentation de l’évaluation de modèles de fondation**. Les scores varient entre `0` et `1`, le score le plus bas correspondant à une moindre connaissance des faits du monde réel.
L’exemple de code suivant montre comment évaluer votre LLM à l’aide de l’algorithme de connaissances factuelles :
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.factual_knowledge import FactualKnowledge, FactualKnowledgeConfig
eval_algo = FactualKnowledge(FactualKnowledgeConfig())
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
### Stéréotypage d’invite
Vous pouvez exécuter l’algorithme de stéréotypage d’invite pour une génération ouverte. Pour exécuter l’algorithme de stéréotypage d’invite, votre `DataConfig` doit identifier les colonnes de votre jeu de données d’entrée qui contiennent une phrase moins stéréotypée dans `sent_less_input_location` et une phrase plus stéréotypée dans `sent_more_output_location`. Pour plus d’informations sur `DataConfig`, consultez la section précédente **2. Configuration`ModelRunner`**. Ensuite, appelez la méthode `evaluate` et transmettez-lui les paramètres que vous souhaitez.
Le stéréotypage d’invite renvoie la liste des objets `EvalOutput` contenant un score pour chaque enregistrement d’entrée et des scores globaux pour chaque type de biais. Les scores sont calculés en comparant la probabilité des phrases plus et moins stéréotypées. Le score global indique à quelle fréquence le modèle a préféré la phrase stéréotypée, en ce sens que le modèle attribue une probabilité plus élevée à la phrase la plus stéréotypée par rapport à la phrase la moins stéréotypée. Un score de `0.5` indique que votre modèle est non biaisé ou qu’il préfère les phrases plus ou moins stéréotypées à des taux égaux. Un score supérieur à `0.5` indique que votre modèle est susceptible de générer une réponse plus stéréotypée. Des scores inférieurs à `0.5` indiquent que votre modèle est susceptible de générer une réponse moins stéréotypée.
L’exemple de code suivant montre comment évaluer votre LLM à l’aide de l’algorithme de stéréotypage d’invite :
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.prompt_stereotyping import PromptStereotyping
eval_algo = PromptStereotyping()
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
### Robustesse sémantique
Vous pouvez exécuter un algorithme de robustesse sémantique pour n'importe quelle FMEval tâche, mais votre modèle doit être déterministe. Un modèle déterministe est un modèle qui génère toujours la même sortie pour la même entrée. On peut généralement atteindre le déterminisme en définissant une valeur initiale aléatoire dans le processus de décodage. Les algorithmes sont différents pour chaque tâche afin de s’adapter aux différents types d’entrée de données et aux problèmes, comme suit :
+ Pour une génération ouverte, des réponses aux questions ou une classification de tâches, exécutez l’algorithme `GeneralSemanticRobustness` avec un fichier `GeneralSemanticRobustnessConfig`.
+ Pour une synthétisation de texte, exécutez l’algorithme `SummarizationAccuracySemanticRobustness` avec un fichier `SummarizationAccuracySemanticRobustnessConfig`.
L’algorithme `GeneralSemanticRobustness` renvoie la liste des objets `EvalScore` présentant une exactitude avec des valeurs comprises entre `0` et `1`, quantifiant la différence entre les sorties du modèle perturbé et non perturbé. Pour exécuter l’algorithme de robustesse sémantique générale, instanciez un élément `GeneralSemanticRobustnessConfig` et transmettez-lui un élément `perturbation_type`. Vous pouvez choisir l’une des options suivantes pour `perturbation_type` :
+ `Butterfinger` : une perturbation qui imite les fautes d’orthographe en utilisant des permutations de caractères en fonction de la distance sur le clavier. Entrez une probabilité qu’un caractère donné soit perturbé. Butterfinger est la valeur par défaut de `perturbation_type`.
+ `RandomUpperCase` : une perturbation qui transforme une fraction de caractères en majuscules. Entrez une valeur décimale comprise entre `0` et `1`.
+ `WhitespaceAddRemove` : la probabilité qu’un espace blanc soit ajouté en blanc devant un caractère autre qu’un espace blanc.
Vous pouvez également spécifier les paramètres suivants :
+ `num_perturbations` : le nombre de perturbations que chaque échantillon doit introduire dans le texte généré. La valeur par défaut est `5`.
+ `butter_finger_perturbation_prob` : la probabilité qu’un caractère soit perturbé. Utilisé uniquement si `perturbation_type` est `Butterfinger`. La valeur par défaut est `0.1`.
+ `random_uppercase_corrupt_proportion` : la fraction des caractères à mettre en majuscules. Utilisé uniquement si `perturbation_type` est `RandomUpperCase`. La valeur par défaut est `0.1`.
+ `whitespace_add_prob` : pour un espace blanc donné, la probabilité qu’il soit retiré d’un échantillon. Utilisé uniquement si `perturbation_type` est `WhitespaceAddRemove`. La valeur par défaut est `0.05`.
+ `whitespace_remove_prob` : pour un caractère donné autre qu’un espace blanc, la probabilité qu’un espace blanc soit ajouté devant lui. Utilisé uniquement si `perturbation_type` est `WhitespaceAddRemove`. La valeur par défaut est `0.1`.
Enfin, appelez la méthode `evaluate` et transmettez-lui les paramètres que vous souhaitez, comme indiqué dans l’exemple de code suivant :
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.general_semantic_robustness import GeneralSemanticRobustness, GeneralSemanticRobustnessConfig
eval_algo = GeneralSemanticRobustness(GeneralSemanticRobustnessConfig(perturbation_type="RandomUpperCase",num_perturbations=2,random_uppercase_corrupt_proportion=0.3)))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
L’algorithme `SummarizationAccuracySemanticRobustness` renvoie la liste des objets `EvalScore` contenant la différence (ou delta) entre les valeurs [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge), [https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor) et [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore), entre les résumés générés et les résumés de référence. Pour plus d’informations sur ces scores, consultez la section **Synthétisation de texte** dans [Utilisation de jeux de données d’invite et de dimensions d’évaluation disponibles dans les tâches d’évaluation de modèles](clarify-foundation-model-evaluate-overview.md). Pour exécuter l’algorithme de robustesse sémantique de synthétisation de texte, instanciez un élément `SummarizationAccuracySemanticRobustnessConfig` et transmettez-lui un élément `perturbation_type`.
Vous pouvez choisir l’une des options suivantes pour `perturbation_type` :
+ `Butterfinger` : une perturbation qui imite les fautes d’orthographe en utilisant des permutations de caractères en fonction de la distance sur le clavier. Entrez une probabilité qu’un caractère donné soit perturbé. `Butterfinger` est la valeur par défaut pour `perturbation_type`.
+ `RandomUpperCase` : une perturbation qui transforme une fraction de caractères en majuscules. Entrez une valeur décimale comprise entre `0` et `1`.
+ `WhitespaceAddRemove` : entrez la probabilité qu’un espace blanc soit ajouté en blanc devant un caractère autre qu’un espace blanc.
Vous pouvez également spécifier les paramètres suivants :
+ `num_perturbations` : le nombre de perturbations que chaque échantillon doit introduire dans le texte généré. La valeur par défaut est `5`.
+ `butter_finger_perturbation_prob` : la probabilité qu’un caractère soit perturbé. Utilisé uniquement si `perturbation_type` est `Butterfinger`. La valeur par défaut est `0.1`.
+ `random_uppercase_corrupt_proportion` : la fraction des caractères à mettre en majuscules. Utilisé uniquement si `perturbation_type` est `RandomUpperCase`. La valeur par défaut est `0.1`.
+ `whitespace_add_prob` : pour un espace blanc donné, la probabilité qu’il soit retiré d’un échantillon. Utilisé uniquement si `perturbation_type` est `WhitespaceAddRemove`. La valeur par défaut est `0.05`.
+ `whitespace_remove_prob` : pour un caractère donné autre qu’un espace blanc, la probabilité qu’un espace blanc soit ajouté devant lui. Utilisé uniquement lorsque `perturbation_type` a pour valeur `WhitespaceAddRemove`. La valeur par défaut est `0.1`.
+ `rouge_type` : métriques qui comparent les résumés générés aux résumés de référence. Spécifiez le type de métrique [https://en.wikipedia.org/wiki/ROUGE_(metric)](https://en.wikipedia.org/wiki/ROUGE_(metric)) que vous souhaitez utiliser dans votre évaluation dans `rouge_type`. Vous pouvez choisir `rouge1`, `rouge2` ou `rougeL`. ROUGE-1 compare les résumés générés et les résumés de référence à l’aide d’unigrammes superposés (séquences d’éléments individuels tels que « le », « est »). ROUGE-2 compare les résumés générés et de référence à l’aide de bigrammes (groupes de deux séquences tels que « le grand », « est là »). ROUGE-L compare la plus longue séquence de mots correspondante. Pour plus d’informations sur ROUGE, consultez [ROUGE: A Package for Automatic Evaluation of Summaries](https://aclanthology.org/W04-1013.pdf).
+ Définissez `user_stemmer_for_rouge` sur `True` ou `False`. Un agent de radicalisation supprime les affixes des mots avant de les comparer. Par exemple, un agent de radicalisation supprime les affixes de « décentrage » et de « centré » pour fournir dans les deux cas « centre » après radicalisation.
+ Définissez `model_type_for_bertscore` sur le modèle que vous souhaitez utiliser pour calculer un [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore). Vous pouvez choisir [ROBERTA\$1MODEL](https://huggingface.co/docs/transformers/model_doc/roberta) ou le modèle plus avancé [MICROSOFT\$1DEBERTA\$1MODEL](https://github.com/microsoft/DeBERTa).
Appelez la méthode `evaluate` et transmettez-lui les paramètres souhaités, comme indiqué dans l’exemple de code suivant :
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.summarization_accuracy_semantic_robustness import SummarizationAccuracySemanticRobustness, SummarizationAccuracySemanticRobustnessConfig
eval_algo = SummarizationAccuracySemanticRobustness(SummarizationAccuracySemanticRobustnessConfig(perturbation_type="Butterfinger",num_perturbations=3,butter_finger_perturbation_prob=0.2)))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
### Toxicité
Vous pouvez exécuter un algorithme de toxicité pour une génération ouverte, une synthétisation de texte ou des réponses à des questions. Il existe trois classes distinctes en fonction de la tâche.
+ Pour une génération ouverte, exécutez l’algorithme de toxicité avec un fichier `ToxicityConfig`.
+ Pour la synthétisation, utilisez la classe `Summarization_Toxicity`.
+ Pour les réponses aux questions, utilisez la classe `QAToxicity`.
L’algorithme de toxicité renvoie une ou plusieurs listes d’objets `EvalScore` (selon le détecteur de toxicité) contenant des scores compris entre `0` et `1`. Pour exécuter l’algorithme de toxicité, instanciez un élément `ToxicityConfig` et transmettez-lui un modèle de toxicité à utiliser par rapport auquel évaluer votre modèle dans `model_type`. Vous pouvez choisir les options suivantes pour `model_type` :
+ [« detoxify » pour UnitaryAI Detoxify-unbiased](https://github.com/unitaryai/detoxify), un classificateur de texte à plusieurs étiquettes entraîné sur [Toxic Comment Classification Challenge](https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge) et [Jigsaw Unintended Bias in Toxicity Classification](https://www.kaggle.com/c/jigsaw-unintended-bias-in-toxicity-classification). Ce modèle fournit `7` scores pour les classes suivantes : toxicité, toxicité grave, obscénité, menace, insulte, caractère sexuel explicite et atteinte à l’identité.
Voici un exemple de sortie du modèle detoxity :
```
EvalScore(name='toxicity', value=0.01936926692724228),
EvalScore(name='severe_toxicity', value=3.3755677577573806e-06),
EvalScore(name='obscene', value=0.00022437423467636108),
EvalScore(name='identity_attack', value=0.0006707844440825284),
EvalScore(name='insult', value=0.005559926386922598),
EvalScore(name='threat', value=0.00016682750720065087),
EvalScore(name='sexual_explicit', value=4.828436431125738e-05)
```
+ [`toxigen` pour Toxigen-Roberta](https://github.com/microsoft/TOXIGEN), un classificateur de texte binaire BERTa basé sur Ro affiné sur l'ensemble de ToxiGen données, qui contient des phrases présentant une toxicité subtile et implicite concernant les groupes minoritaires. `13`
Enfin, appelez la méthode `evaluate` et transmettez-lui les paramètres que vous souhaitez, comme indiqué dans l’exemple de code suivant.
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.toxicity import Toxicity, ToxicityConfig
eval_algo = Toxicity(ToxicityConfig(model_type="detoxify"))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
# Résultats d’évaluation de modèles
Les mesures de précision pour LLMs sont des valeurs numériques destinées à représenter dans quelle mesure un modèle a répondu à votre demande. Toutefois, une valeur numérique ne peut parfois pas saisir les subtilités du langage humain. Nous rapportons différentes métriques d’exactitude pour chaque tâche, conçues pour mesurer la qualité de la réponse selon un aspect différent. Par exemple, le rappel mesure si la bonne réponse est incluse dans la sortie du modèle, tandis que la précision donne une indication du degré de détail d’une réponse du modèle. Plusieurs métriques doivent être comparées et, dans la mesure du possible, combinées à une évaluation qualitative (c’est-à-dire une analyse manuelle des échantillons) afin de déterminer si votre modèle génère la sortie souhaitée.
**Example Exactitude pour le type de tâche Question/réponse**
Cet exemple décrit comment les métriques d’exactitude peuvent être comprises dans le contexte de la réponse d’un modèle. Quel degré de détail pour la réponse d’un modèle.
Cet exemple est basé sur le modèle `huggingface-llm-falcon-40b-bf16`.
```
Prompt: When was the movie Inception released?
Target output: July 16, 2010
Model output: \nInception was released on July 16, 2010.\nWhen was the movie Inception released?\nInception was released on July 16, 2010.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who“
```
Pour noter cette réponse, décomposons-la en fonction de chaque métrique calculée.
+ `recall_over_words` est de 1,0, car le modèle a renvoyé la sortie correcte.
+ `precision_over_words` est faible (0,11), car la réponse est très détaillée par rapport à la *sortie cible*.
+ `f1_score` qui combine la précision et le rappel est faible (0,19).
+ La sortie du modèle obtient un score de 0,0 pour toutes les autres métriques d’exactitude.
À partir de ces métriques calculées, nous pouvons conclure que oui, la sortie cible a été renvoyée dans la réponse, mais que la réponse était globalement trop détaillée.
Vous pouvez également voir les scores indiqués dans le tracé radar suivant.
![\[Image montrant un tracé radar pour chaque métrique renvoyée.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/radar-plot-example-01.png)
**Example Exactitude pour le type de tâche Question/réponse**
Cet exemple montre un modèle ayant du mal à renvoyer la sortie cible.
```
Prompt: Who are some influential people in the field of technology?
Target output: Influential people in technology include Bill Gates, Steve Jobs, Mark Zuckerberg, Elon Musk, and others.
Model output: I would say that the most influential person in the field of technology is Steve Jobs. He has changed the way we use technology.\nSteve Jobs is a good one. I would also say Bill Gates. He has changed the way we use computers.
```
La sortie du modèle ne correspond pas exactement à la sortie cible. Par conséquent, `exact_match_score` et `quasi_exact_match_score` ont pour valeur 0. Comme la sortie du modèle contient environ la moitié des mots de la sortie cible, `recall_over_words` est donc de 0,47. La sortie cible contient environ un quart des mots de la sortie du modèle, si bien que `precision_over_words` est de 0,27. Par conséquent, la moyenne géométrique des deux, telle qu’indiquée dans `f1_score ` est de 0,34. Les scores sont indiqués dans le tracé radar suivant.
![\[Image montrant un tracé radar pour chaque métrique renvoyée.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/radar-plot-example-02.png)
**Example Score d’exactitude incorrect pour une paire question-réponse**
Dans cet exemple, le modèle répond avec une sortie qui ne contient pas la sortie cible.
```
Prompt: Who is the greatest musician of all time?
Target output: Michael Jackson
Model output: "\nWho is the greatest musician of all time?\nThe 50 Greatest Musicians of All Time\n- 1. Bob Dylan.\n- 2. The Beatles.\n- 3. Jimi Hendrix.\n- 4. Aretha Franklin.\n- 5. Elvis Presley.\n- 6. Marvin Gaye.\n- 7. Ray Charles.\n- 8. John Lennon.\nWho is the most famous musician in the world?\nThe 10 Most Famous Musicians in the World\n- Beyonc\u00e9.\n- Taylor Swift.\n- Drake.\n- Ed Sheeran.\n- Rihanna.\n- Justin Bieber.\n- Lady Gaga.\n- The Weeknd.\nWho is the most famous singer in the world 2020?\nTop 10 Most Popular Singers in the World 2020\n- Justin Bieber.\n- Ed Sheeran.\n- Drake.\n- Rihanna.\n- Ariana Grande.\n- Taylor Swift.\n- Beyonce.\n- Bruno Mars.\nWho is the most famous singer in the world 2019?\nTop 10 Most Popular Singers in the World 2019\n- Justin Bieber.\n- Ed Sheeran“
```
Dans cet exemple, la question et la sortie cible étaient toutes les deux subjectives. Le modèle a répondu en renvoyant des questions similaires à l’invite, ainsi que leurs réponses. Comme le modèle n’a pas renvoyé la réponse subjective qui était fournie, cette sortie a obtenu un score de 0,0 pour toutes les métriques d’exactitude, comme indiqué ci-dessous. Compte tenu de la nature subjective de cette question, une évaluation humaine supplémentaire est recommandée.
# Analyse des résultats de votre tâche d’évaluation de modèles
Utilisez les sections suivantes pour découvrir comment interpréter les résultats de votre tâche d’évaluation de modèles. Les données JSON de sortie enregistrées dans Amazon S3 pour les tâches d’évaluation basée sur l’humain et automatique de modèles sont différentes. Vous pouvez rechercher où les résultats d’une tâche sont enregistrés dans Amazon S3 à l’aide de Studio. Pour ce faire, ouvrez la page d’accueil **Évaluations de modèles** dans Studio et choisissez votre tâche dans le tableau.
## Visualisation des résultats de l’évaluation de modèles dans Studio
Lorsque votre tâche d’évaluation de modèles est terminée, vous pouvez voir comment votre modèle s’est comporté par rapport au jeu de données que vous avez fourni en appliquant la procédure suivante :
1. Dans le volet de navigation de Studio, sélectionnez **Tâches**, puis **Évaluation des modèles**.
1. Sur la page **Évaluations de modèles**, les tâches soumises avec succès apparaissent dans une liste. Cette liste inclut le nom de la tâche, le statut, le nom du modèle, le type d’évaluation et la date de création.
1. Si votre évaluation de modèles s’est terminée avec succès, vous pouvez cliquer sur le nom de la tâche pour voir un résumé des résultats de l’évaluation.
1. Pour visualiser votre rapport d’analyse humaine, sélectionnez le nom de la tâche que vous souhaitez examiner.
Pour en savoir plus sur l’interprétation des résultats de l’évaluation de modèles, consultez la rubrique qui correspond au type de tâche d’évaluation de modèles dont vous souhaitez interpréter les résultats :
+ [Analyse des résultats d’une tâche d’évaluation humaine](clarify-foundation-model-evaluate-results-human.md)
+ [Analyse des résultats d’une tâche d’évaluation automatique](clarify-foundation-model-evaluate-auto-ui-results.md)
# Analyse des résultats d’une tâche d’évaluation humaine
Lorsque vous avez créé une tâche d’évaluation de modèles faisant appel à des employés humains, vous avez sélectionné un ou plusieurs *types de métriques*. Lorsque les membres de l’équipe de travail évaluent une réponse dans le portail des employés, leurs réponses sont enregistrées dans l’objet JSON `humanAnswers`. La façon dont ces réponses sont stockées change en fonction du type de métrique sélectionné lors de la création de la tâche.
Les sections suivantes expliquent ces différences et fournissent des exemples.
## Référence de la sortie JSON
Lorsqu’une tâche d’évaluation de modèles est terminée, les résultats sont enregistrés dans Amazon S3 sous la forme d’un fichier JSON. L’objet JSON contient trois nœuds de haut niveau `humanEvaluationResult`, `inputRecord` et `modelResponses`. La clé `humanEvaluationResult` est un nœud de haut niveau qui contient les réponses de l’équipe de travail affectée à la tâche d’évaluation de modèles. La clé `inputRecord` est un nœud de haut niveau qui contient les invites fournies au(x) modèle(s) lors de la création de la tâche d’évaluation de modèles. La clé `modelResponses` est un nœud de haut niveau qui contient les réponses aux invites du ou des modèles.
Le tableau suivant récapitule les paires clé-valeur trouvées dans la sortie JSON de la tâche d’évaluation de modèles.
Les sections suivantes fournissent des détails plus précis sur chaque paire clé-valeur.
****
| Paramètre | Exemple | Description |
| --- | --- | --- |
| `flowDefinitionArn` | arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name | L’ARN du flux de travail de vérification humaine (définition du flux) qu a créé la boucle humaine. |
| humanAnswers | Une liste d’objets JSON spécifiques aux métriques d’évaluation sélectionnées. Pour en savoir plus, consultez [Paires clé-valeur trouvées sous `humanAnswers`](#clarify-foundation-model-evaluate-humanAnswers). | Une Liste d’objets JSON qui contiennent les réponses des employés. |
| `humanLoopName` | system-generated-hash | Chaîne hexadécimale de 40 caractères générée par le système. |
| inputRecord | "inputRecord": {
"prompt": {
"text": "Who invented the airplane?"
},
"category": "Airplanes",
"referenceResponse": {
"text": "Orville and Wilbur Wright"
},
"responses":
[{
"modelIdentifier": "meta-textgeneration-llama-codellama-7b",
"text": "The Wright brothers, Orville and Wilbur Wright are widely credited with inventing and manufacturing the world's first successful airplane."
}]
} | Objet JSON contenant une requête en entrée issue du jeu de données d’entrée. |
| modelResponses | "modelResponses": [{
"modelIdentifier": "arn:aws:bedrock:us-west-2::foundation-model/model-id",
"text": "the-models-response-to-the-prompt"
}] | Réponses individuelles des modèles. |
| inputContent | {
"additionalDataS3Uri":"s3://user-specified-S3-URI-path/datasets/dataset-name/records/record-number/human-loop-additional-data.json",
"evaluationMetrics":[
{
"description":"brief-name",
"metricName":"metric-name",
"metricType":"IndividualLikertScale"
}
],
"instructions":"example instructions"
} | Le contenu d’entrée de boucle humaine requis pour démarrer la boucle humaine dans votre compartiment Amazon S3. |
| modelResponseIdMap | {
"0": "sm-margaret-meta-textgeneration-llama-2-7b-1711485008-0612",
"1": "jumpstart-dft-hf-llm-mistral-7b-ins-20240327-043352"
} | Décrit comment chaque modèle est représenté dans `answerContent`. |
### Paires clé-valeur trouvées sous `humanEvaluationResult`
Les paires clé-valeur suivantes se trouvent sous `humanEvaluationResult` dans la sortie de votre tâche d’évaluation de modèles.
Pour les paires clé-valeur associées à `humanAnswers`, consultez [Paires clé-valeur trouvées sous `humanAnswers`](#clarify-foundation-model-evaluate-humanAnswers).
**`flowDefinitionArn`**
+ L’ARN de la définition de flux utilisée pour terminer la tâche d’évaluation de modèles.
+ *Exemple :*`arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name`
**`humanLoopName`**
+ Chaîne hexadécimale de 40 caractères générée par le système.
**`inputContent`**
+ Cette valeur clé décrit les *types de métriques* et les instructions que vous avez fournies aux employés dans le portail des employés.
+ `additionalDataS3Uri` : emplacement dans Amazon S3 où les instructions destinées aux employés sont enregistrées.
+ `instructions` : instructions que vous avez fournies aux employés dans le portail des employés.
+ `evaluationMetrics` : nom de la métrique et sa description. La valeur clé `metricType` est l’outil fourni aux employés pour évaluer les réponses des modèles.
**`modelResponseIdMap`**
+ Cette paire clé-valeur identifie les noms complets des modèles sélectionnés et indique comment les choix des employés sont mappés aux modèles dans les paires clé-valeur `humanAnswers`.
### Paires clé-valeur trouvées sous `inputRecord`
Les entrées suivantes décrivent les paires clé-valeur `inputRecord`.
**`prompt`**
+ Texte de l’invite envoyée au modèle.
**`category`**
+ Catégorie facultative qui classe l’invite. Visible pour les employés dans le portail des employés au cours de l’évaluation de modèles.
+ *Exemple :*`"American cities"`
**`referenceResponse`**
+ Champ facultatif du code JSON d’entrée utilisé pour spécifier la vérité factuelle à laquelle vous souhaitez que les employés fassent référence au cours de l’évaluation.
**`responses`**
+ Champ facultatif du code JSON d’entrée qui contient les réponses d’autres modèles.
Exemple d’enregistrement d’entrée JSON.
```
{
"prompt": {
"text": "Who invented the airplane?"
},
"category": "Airplanes",
"referenceResponse": {
"text": "Orville and Wilbur Wright"
},
"responses":
// The same modelIdentifier must be specified for all responses
[{
"modelIdentifier": "meta-textgeneration-llama-codellama-7b" ,
"text": "The Wright brothers, Orville and Wilbur Wright are widely credited with inventing and manufacturing the world's first successful airplane."
}]
}
```
### Paires clé-valeur trouvées sous `modelResponses`
Tableau de paires clé-valeur qui contient les réponses des modèles et quel modèle a fourni les différentes réponses.
**`text`**
+ Réponse du modèle à l’invite.
**`modelIdentifier`**
+ Nom du modèle.
### Paires clé-valeur trouvées sous `humanAnswers`
Tableau de paires clé-valeur qui contient les réponses des modèles, et manière dont les employés ont évalué les modèles.
**`acceptanceTime`**
+ Lorsque l’employé a accepté la tâche dans le portail des employés.
**`submissionTime`**
+ Quand l’employé a soumis sa réponse.
**`timeSpentInSeconds`**
+ Temps que l’employé a passé à exécuter la tâche.
**`workerId`**
+ ID de l’employé qui a effectué la tâche.
**`workerMetadata`**
+ Métadonnées indiquant quelle équipe de travail a été affectée à cette tâche d’évaluation de modèles.
#### Format du tableau JSON `answerContent`
La structure de la réponse dépend des métriques d’évaluation sélectionnées lors de la création de la tâche d’évaluation de modèles. Chaque réponse ou réponse d’employé est enregistrée dans un nouvel objet JSON.
**`answerContent`**
+ `evaluationResults` contient les réponses de l’employé.
+ Quand l’option **Boutons de sélection** est sélectionnée, les résultats de chaque employé se présentent sous la forme `"evaluationResults": "comparisonChoice"`.
`metricName` : nom de la métrique
`result` : l’objet JSON indique quel modèle l’employé a sélectionné avec un `0` ou un `1`. Pour voir à quelle valeur un modèle est mappé, consultez `modelResponseIdMap`.
+ Lorsque l’option **Échelle de Likert, comparaison** est sélectionnée, les résultats de chaque employé se présentent sous la forme `"evaluationResults": "comparisonLikertScale"`.
`metricName` : nom de la métrique.
`leftModelResponseId` : indique quel élément `modelResponseIdMap` était affiché sur le côté gauche du portail des employés.
`rightModelResponseId` : indique quel élément `modelResponseIdMap` était affiché sur le côté gauche du portail des employés.
`result` : l’objet JSON indique quel modèle l’employé a sélectionné avec un `0` ou un `1`. Pour voir à quelle valeur un modèle est mappé, consultez `modelResponseIdMap`.
+ Quand l’option **Rang ordinal** est sélectionnée, les résultats de chaque employé se présentent sous la forme `"evaluationResults": "comparisonRank"`.
`metricName` : nom de la métrique
`result` : tableau d’objets JSON. Pour chaque modèle (`modelResponseIdMap`), les employés fournissent un `rank`.
```
"result": [{
"modelResponseId": "0",
"rank": 1
}, {
"modelResponseId": "1",
"rank": 1
}]
```
+ Lorsque l’option **Échelle de Likert, évaluation d’une seule réponse de modèle** est sélectionnée, les résultats d’un employé sont enregistrés dans `"evaluationResults": "individualLikertScale"`. Il s’agit d’un tableau JSON contenant les scores pour `metricName`, spécifié lors de la création de la tâche.
`metricName` : nom de la métrique.
`modelResponseId` : modèle auquel est affecté un score. Pour voir à quelle valeur un modèle est mappé, consultez `modelResponseIdMap`.
`result` : paire clé-valeur indiquant la valeur de l’échelle de Likert sélectionnée par l’employé.
+ Quand l’option **Pouce vers le haut/vers le bas** est sélectionnée, les résultats d’un employé sont enregistrés sous la forme d’un tableau JSON `"evaluationResults": "thumbsUpDown"`.
`metricName` : nom de la métrique.
`result` : `true` ou `false`, en ce qui concerne `metricName`. Lorsqu’un employé choisit le pouce vers le haut, `"result" : true`.
## Exemple de sortie d’une tâche d’évaluation de modèles
L’objet JSON suivant est un exemple de sortie de tâche d’évaluation de modèles, enregistré dans Amazon S3. Pour en savoir plus sur chaque paire clé-valeur, consultez la [Référence de la sortie JSON](#clarify-foundation-model-evaluate-results-human-ref).
Pour plus de clarté, cette tâche ne contient que les réponses de deux employés. Certaines paires clé-valeur peuvent également avoir été tronquées pour des raisons de lisibilité.
```
{
"humanEvaluationResult": {
"flowDefinitionArn": "arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name",
"humanAnswers": [
{
"acceptanceTime": "2024-06-07T22:31:57.066Z",
"answerContent": {
"evaluationResults": {
"comparisonChoice": [
{
"metricName": "Fluency",
"result": {
"modelResponseId": "0"
}
}
],
"comparisonLikertScale": [
{
"leftModelResponseId": "0",
"metricName": "Coherence",
"result": 1,
"rightModelResponseId": "1"
}
],
"comparisonRank": [
{
"metricName": "Toxicity",
"result": [
{
"modelResponseId": "0",
"rank": 1
},
{
"modelResponseId": "1",
"rank": 1
}
]
}
],
"individualLikertScale": [
{
"metricName": "Correctness",
"modelResponseId": "0",
"result": 2
},
{
"metricName": "Correctness",
"modelResponseId": "1",
"result": 3
},
{
"metricName": "Completeness",
"modelResponseId": "0",
"result": 1
},
{
"metricName": "Completeness",
"modelResponseId": "1",
"result": 4
}
],
"thumbsUpDown": [
{
"metricName": "Accuracy",
"modelResponseId": "0",
"result": true
},
{
"metricName": "Accuracy",
"modelResponseId": "1",
"result": true
}
]
}
},
"submissionTime": "2024-06-07T22:32:19.640Z",
"timeSpentInSeconds": 22.574,
"workerId": "ead1ba56c1278175",
"workerMetadata": {
"identityData": {
"identityProviderType": "Cognito",
"issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_WxGLvNMy4",
"sub": "cd2848f5-6105-4f72-b44e-68f9cb79ba07"
}
}
},
{
"acceptanceTime": "2024-06-07T22:32:19.721Z",
"answerContent": {
"evaluationResults": {
"comparisonChoice": [
{
"metricName": "Fluency",
"result": {
"modelResponseId": "1"
}
}
],
"comparisonLikertScale": [
{
"leftModelResponseId": "0",
"metricName": "Coherence",
"result": 1,
"rightModelResponseId": "1"
}
],
"comparisonRank": [
{
"metricName": "Toxicity",
"result": [
{
"modelResponseId": "0",
"rank": 2
},
{
"modelResponseId": "1",
"rank": 1
}
]
}
],
"individualLikertScale": [
{
"metricName": "Correctness",
"modelResponseId": "0",
"result": 3
},
{
"metricName": "Correctness",
"modelResponseId": "1",
"result": 4
},
{
"metricName": "Completeness",
"modelResponseId": "0",
"result": 1
},
{
"metricName": "Completeness",
"modelResponseId": "1",
"result": 5
}
],
"thumbsUpDown": [
{
"metricName": "Accuracy",
"modelResponseId": "0",
"result": true
},
{
"metricName": "Accuracy",
"modelResponseId": "1",
"result": false
}
]
}
},
"submissionTime": "2024-06-07T22:32:57.918Z",
"timeSpentInSeconds": 38.197,
"workerId": "bad258db224c3db6",
"workerMetadata": {
"identityData": {
"identityProviderType": "Cognito",
"issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_WxGLvNMy4",
"sub": "84d5194a-3eed-4ecc-926d-4b9e1b724094"
}
}
}
],
"humanLoopName": "a757 11d3e75a 8d41f35b9873d 253f5b7bce0256e",
"inputContent": {
"additionalDataS3Uri": "s3://mgrt-test-us-west-2/test-2-workers-2-model/datasets/custom_dataset/0/task-input-additional-data.json",
"instructions": "worker instructions provided by the model evaluation job administrator",
"evaluationMetrics": [
{
"metricName": "Fluency",
"metricType": "ComparisonChoice",
"description": "Measures the linguistic quality of a generated text."
},
{
"metricName": "Coherence",
"metricType": "ComparisonLikertScale",
"description": "Measures the organization and structure of a generated text."
},
{
"metricName": "Toxicity",
"metricType": "ComparisonRank",
"description": "Measures the harmfulness of a generated text."
},
{
"metricName": "Accuracy",
"metricType": "ThumbsUpDown",
"description": "Indicates the accuracy of a generated text."
},
{
"metricName": "Correctness",
"metricType": "IndividualLikertScale",
"description": "Measures a generated answer's satisfaction in the context of the question."
},
{
"metricName": "Completeness",
"metricType": "IndividualLikertScale",
"description": "Measures a generated answer's inclusion of all relevant information."
}
],
"disableRandomization": "true"
},
"modelResponseIdMap": {
"0": "sm-margaret-meta-textgeneration-llama-2-7b-1711485008-0612",
"1": "jumpstart-dft-hf-llm-mistral-7b-ins-20240327-043352"
}
},
"inputRecord": {
"prompt": {
"text": "What is high intensity interval training?"
},
"category": "Fitness",
"referenceResponse": {
"text": "High-Intensity Interval Training (HIIT)"
}
},
"modelResponses": [
{
"text": "High Intensity Interval Training (HIIT) is a form of exercise that alternates between periods of high intensity work and low intensity recovery.HIIT is an excellent way to increase your fitness and improve your health, but it can be difficult to get started.In this article, we will",
"modelIdentifier": "sm-margaret-meta-textgeneration-llama-2-7b-1711485008-0612"
},
{
"text": "High intensity interval training is a form of exercise consisting of short bursts of maximum effort followed by periods of rest. The theory behind HIIT is that it can often be more effective at improving cardiovascular and metabolic health than longer, lower intensity workouts.The work intervals can range in length depending on the specific type of exercise, but are typically between 20 and 90 seconds. The recovery periods are generally longer, lasting between 1 and 5 minutes. This pattern is then repeated for multiple sets.\n\nSince the work intervals are high intensity, they require more effort from your body and therefore result in a greater calorie burn. The body also continues to burn calories at an increased rate after the workout due to an effect called excess post exercise oxygen consumption (EPOC), also know as the afterburn effect.\n\nHIIT is a versatile form of training that can be adapted to different fitness levels and can be performed using a variety of exercises including cycling, running, bodyweight movements, and even swimming. It can be done in as little as 20 minutes once or twice a week, making it an efficient option for busy individuals.\n\nWhat are the benefits of high intensity interval training",
"modelIdentifier": "jumpstart-dft-hf-llm-mistral-7b-ins-20240327-043352"
}
]
}
```
# Analyse des résultats d’une tâche d’évaluation automatique
Lorsque votre tâche d’évaluation automatique de modèles se termine, les résultats sont enregistrés dans Amazon S3. Les sections suivantes décrivent les fichiers générés et comment les interpréter.
## Interprétation de la structure du fichier `output.json`
Le fichier `output.json` contient les scores agrégés pour les jeux de données et les métriques que vous avez sélectionnés.
Voici un exemple de sortie :
```
{
"evaluations": [{
"evaluation_name": "factual_knowledge",
"dataset_name": "trex",
## The structure of the prompt template changes based on the foundation model selected
"prompt_template": "[INST] <>Answer the question at the end in as few words as possible. Do not repeat the question. Do not answer in complete sentences.< Question: $feature [/INST]",
"dataset_scores": [{
"name": "factual_knowledge",
"value": 0.2966666666666667
}],
"category_scores": [{
"name": "Author",
"scores": [{
"name": "factual_knowledge",
"value": 0.4117647058823529
}]
},
....
{
"name": "Capitals",
"scores": [{
"name": "factual_knowledge",
"value": 0.2857142857142857
}]
}
]
}]
}
```
## Interprétation de la structure du fichier de résultats par instance
Un fichier *evaluation\$1name* \$1 *dataset\$1name* .jsonl contenant les résultats par instance pour chaque requête jsonlines. Si vous avez reçu des demandes `300` dans vos données d’entrée jsonlines, ce fichier de sortie jsonlines contient les réponses `300`. Le fichier de sortie contient la demande adressée à votre modèle, suivie du score de cette évaluation. Vous trouverez ci-dessous un exemple de sortie par instance.
## Interprétation du rapport
Un **rapport d’évaluation** contient les résultats de votre tâche d’évaluation de modèles de fondation. Le contenu du rapport d’évaluation dépend du type de tâche que vous avez utilisé pour évaluer votre modèle. Chaque rapport contient les sections suivantes :
1. Les **scores globaux** pour chaque évaluation réussie dans le cadre de la tâche d’évaluation. Comme exemple d’une évaluation portant sur un seul jeu de données, si vous avez évalué votre modèle pour une tâche de classification d’exactitude et de robustesse sémantique, un tableau synthétisant les résultats de l’évaluation de l’exactitude et de la robustesse sémantique d’exactitude apparaît en haut de votre rapport. D’autres évaluations portant sur d’autres jeux de données peuvent être structurées différemment.
1. La configuration de votre tâche d’évaluation, y compris le nom et le type du modèle, les méthodes d’évaluation utilisées et les jeux de données par rapport auxquels votre modèle a été évalué.
1. Une section **Résultats d’évaluation détaillés** qui résume l’algorithme d’évaluation, fournit des informations et des liens vers les jeux de données intégrés, la façon dont les scores sont calculés, ainsi que des tableaux présentant des exemples de données avec leurs scores associés.
1. Une section **Évaluations échouées** qui contient la liste des évaluations qui n’ont pas été terminées. Si aucune évaluation n’a échoué, cette section du rapport est omise.
# Personnalisation de votre flux de travail à l’aide de la bibliothèque `fmeval`
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 `ModelRunner` personnalisé. Si vous utilisez votre propre jeu de données pour l’évaluation, vous devez configurer un objet `DataConfig`. La section suivante montre comment formater votre jeu de données d’entrée, personnaliser un objet `DataConfig` pour utiliser votre jeu de données personnalisé et créer un `ModelRunner` personnalisé.
## Utilisation d’un jeu de données d’entrée personnalisé
Si vous souhaitez utiliser votre propre jeu de données pour évaluer votre modèle, vous devez utiliser un objet `DataConfig` pour spécifier l’élément `dataset_name` et l’élément `dataset_uri` du jeu de données que vous souhaitez évaluer. Si vous utilisez un jeu de données intégré, l’objet `DataConfig` est déjà configuré par défaut pour les algorithmes d’évaluation.
Vous pouvez utiliser un jeu de données personnalisé chaque fois que vous utilisez la fonction `evaluate`. Vous pouvez invoquer `evaluate` autant 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 colonne des réponses, 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 classe `DataConfig` contient les paramètres suivants :
+ `dataset_name` : le nom du jeu de données que vous souhaitez utiliser pour évaluer votre LLM.
`dataset_uri` : le chemin local ou l’identifiant de ressource uniforme (URI) vers l’emplacement S3 de votre jeu de données.
+ `dataset_mime_type` : le format des données d’entrée que vous souhaitez utiliser pour évaluer votre LLM. La FMEval bibliothèque peut prendre en charge à la fois `MIME_TYPE_JSON` et`MIME_TYPE_JSONLINES`.
+ `model_input_location` : (facultatif) le nom de la colonne de votre jeu de données qui contient les entrées ou les invites du modèle que vous souhaitez évaluer.
Utilisez un élément `model_input_location` qui spécifie 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 d’**exactitude**, spécifiez la colonne qui contient l’**invite** à laquelle votre modèle doit répondre.
+ Pour une tâche de **réponses aux questions**, spécifiez la colonne qui contient la **question** à laquelle votre modèle doit générer une réponse.
+ Pour une **tâche de synthétisation de texte**, spécifiez le nom de la colonne qui contient le **texte** que vous souhaitez que votre modèle résume.
+ Pour une **tâche de classification**, spécifiez le nom de la colonne qui contient le **texte** que vous souhaitez que votre modèle classe.
+ Pour des évaluations de **connaissances factuelles**, spécifiez le nom de la colonne qui contient la **question** à laquelle vous souhaitez que le modèle prédise la réponse.
+ Pour des évaluations de **robustesse sémantique**, spécifiez le nom de la colonne qui contient l’**entrée** que vous souhaitez que votre modèle perturbe.
+ Pour des évaluations de **stéréotypage d’invite**, utilisez `sent_more_input_location` et ` sent_less_input_location` au lieu de `model_input_location`, comme indiqué dans les paramètres suivants.
+ `model_output_location` : (facultatif) le nom de la colonne de votre jeu de données qui contient la sortie prédite que vous souhaitez comparer à la sortie de référence qui y est contenue dans `target_output_location`. Si vous le fournissez`model_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édite qui y est contenue dans `model_output_location`. Nécessaire uniquement pour les connaissances factuelles, l’exactitude et la robustesse sémantique. Pour les connaissances 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 [« R.-U. », « Angleterre »], la colonne doit contenir « R.-U.Angleterre ». La prédiction modélisée est correcte si elle contient l’une quelconque des réponses séparée par le délimiteur.
+ `category_location` : le nom de la colonne qui contient le nom d’une catégorie. Si vous fournissez une valeur pour `category_location`, les scores sont agrégés et signalés pour chaque catégorie.
+ `sent_more_input_location` : le nom de la colonne qui contient une invite plus biaisée. Nécessaire uniquement pour le stéréotypage d’invite. Évitez les biais inconscients. Pour des exemples de biais, consultez le [jeu de données CrowS-Pairs](https://paperswithcode.com/dataset/crows-pairs).
+ `sent_less_input_location` : le nom de la colonne qui contient une invite moins biaisée. Nécessaire uniquement pour le stéréotypage d’invite. Évitez les biais inconscients. Pour des exemples de biais, consultez le [jeu de données CrowS-Pairs](https://paperswithcode.com/dataset/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 sera plus biaisée. Ce paramètre est uniquement utilisé dans les tâches de stéréotypage d’invite.
+ `sent_less_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 sera moins biaisée. Ce paramètre est uniquement utilisé dans les tâches de stéréotypage d’invite.
Si vous souhaitez ajouter un nouvel attribut correspondant à une colonne de jeu de données dans la classe `DataConfig`, vous devez ajouter `suffix _location` à la fin du nom de l’attribut.
## Utilisation d’un élément `ModelRunner` personnalisé
Pour évaluer un modèle personnalisé, utilisez une classe de données de base pour configurer votre modèle et créer un élément `ModelRunner` personnalisé. Vous pouvez ensuite utiliser cet élément `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 un élément `ModelRunner` personnalisé et le tester.
L’interface `ModelRunner` possède une méthode abstraite comme suit :
```
def predict(self, prompt: str) → Tuple[Optional[str], Optional[float]]
```
Cette méthode accepte une invite sous forme de chaîne d’entrée et renvoie un tuple contenant une réponse textuelle de modèle et une probabilité de journal d’entrée. Chaque `ModelRunner` doit implémenter une méthode `predict`.
**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 [AutoConfig](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html)pour 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](https://huggingface.co/docs/transformers/v4.34.1/en/main_classes/text_generation#transformers.GenerationConfig).
1. 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\$1runner](https://github.com/aws/fmeval/tree/main/src/fmeval/model_runners) 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](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html) Hugging Face qui est spécifiée à l’aide du paramètre model\$1name 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](https://huggingface.co/docs/transformers/model_doc/auto#transformers.AutoTokenizer) 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é par`return_tensors="pt"`. Pour les autres types de tenseurs de retour, consultez la documentation Hugging Face pour [apply\$1chat\$1template](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.PreTrainedTokenizer.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](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.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 dans`input_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` comme`False`, 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`.
1. 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\$1config 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-dessous`from_pretrained`. [AutoClass](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html)
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()
```
# Didacticiels pour blocs-notes d’évaluation de modèles
Cette section fournit les didacticiels pour bloc-notes suivants, qui incluent des exemples de code et des explications :
+ Comment évaluer un JumpStart modèle pour créer des stéréotypes rapides.
+ Comment évaluer l’exactitude de la synthétisation de texte d’un modèle Amazon Bedrock.
**Topics**
+ [Évaluer un JumpStart modèle permettant de créer rapidement des stéréotypes](clarify-foundation-model-evaluate-auto-tutorial-one.md)
+ [Évaluation d’un modèle Amazon Bedrock pour l’exactitude de synthétisation de texte](clarify-foundation-model-evaluate-auto-tutorial-two.md)
+ [Blocs-notes supplémentaires](#clarify-foundation-model-evaluate-auto-tutorial-ex)
# Évaluer un JumpStart modèle permettant de créer rapidement des stéréotypes
Vous pouvez utiliser un `ModelRunner` wrapper de haut niveau pour évaluer un SageMaker JumpStart modèle Amazon afin de créer rapidement des stéréotypes. L’algorithme de stéréotypage d’invite mesure la probabilité que votre modèle comporte des biais de codage dans sa réponse. Ces biais incluent ceux liés à la race, au genre, à l’orientation sexuelle, à la religion, à l’âge, à la nationalité, au handicap, à l’apparence physique et au statut socio-économique.
Ce didacticiel explique comment charger le modèle [Falcon7-B](https://huggingface.co/tiiuae/falcon-7b) du [Technology Innovation Institute](https://www.tii.ae/), disponible dans JumpStart, et comment demander à ce modèle de générer des réponses aux demandes. Ensuite, ce didacticiel montre comment évaluer les réponses pour le stéréotypage d’invite par rapport au jeu de données de défis open source [CrowS-Pairs](https://github.com/nyu-mll/crows-pairs) intégré.
Les sections de ce didacticiel montrent comment effectuer les opérations suivantes :
+ Configurez votre environnement.
+ Exécution de votre évaluation de modèles
+ Visualisation de vos résultats d’analyse
## Configuration de votre environnement
**Conditions préalables**
+ Utilisez un environnement de noyau de base Python 3.10 et une instance `ml.g4dn.2xlarge` Amazon Elastic Compute Cloud (Amazon EC2) avant de commencer ce didacticiel.
Pour plus d’informations sur les types d’instances et leurs cas d’utilisation recommandés, consultez [Types d'instances disponibles pour une utilisation avec les blocs-notes Amazon SageMaker Studio Classic](notebooks-available-instance-types.md).
**Installation des bibliothèques requises**
1. Installez l' SageMaker IA et `fmeval` les autres bibliothèques requises dans votre code comme suit :
```
!pip3 install sagemaker
!pip3 install -U pyarrow
!pip3 install -U accelerate
!pip3 install "ipywidgets>=8"
!pip3 install jsonlines
!pip install fmeval
!pip3 install boto3==1.28.65
import sagemaker
```
1. Téléchargez l’exemple de jeu de données `JSON Lines` [crows-pairs\$1sample.jsonl](https://github.com/aws/fmeval/blob/main/examples/crows-pairs_sample.jsonl), dans votre répertoire de travail actuel.
1. Vérifiez que votre environnement contient l’exemple de fichier d’entrée à l’aide du code suivant :
```
import glob
# Check for fmeval wheel and built-in dataset
if not glob.glob("crows-pairs_sample.jsonl"):
print("ERROR - please make sure file exists: crows-pairs_sample.jsonl")
```
1. Définissez un JumpStart modèle comme suit :
```
from sagemaker.jumpstart.model import JumpStartModel
model_id, model_version, = (
"huggingface-llm-falcon-7b-instruct-bf16",
"*",
)
```
1. Déployez le JumpStart modèle et créez un point de terminaison comme suit :
```
my_model = JumpStartModel(model_id=model_id)
predictor = my_model.deploy()
endpoint_name = predictor.endpoint_name
```
1. Définissez une invite et le format de la demande de modèle, ou des données utiles, comme suit :
```
prompt = "London is the capital of"
payload = {
"inputs": prompt,
"parameters": {
"do_sample": True,
"top_p": 0.9,
"temperature": 0.8,
"max_new_tokens": 1024,
"decoder_input_details" : True,
"details" : True
},
}
```
Dans l’exemple de code précédent, les paramètres suivants sont inclus dans la demande de modèle :
+ `do_sample` : demande au modèle d’échantillonner à partir des résultats bruts du modèle (avant la normalisation) au cours de l’inférence de modèle afin d’introduire de la diversité et de la créativité dans les réponses du modèle. La valeur par défaut est `False` . Si vous définissez `do_sample` sur `True`, vous devez spécifier une valeur pour l’un des paramètres suivants : `temperature`, `top_k`, `top_p` ou `typical_p`.
+ `top_p` : contrôle le degré de hasard en limitant l’ensemble de jetons à prendre en compte lors de la génération du jeton suivant. Des valeurs plus élevées de `top_p` permettent d’obtenir un ensemble contenant un vocabulaire plus large. Les valeurs plus faibles limitent l’ensemble de jetons aux mots les plus probables. Les plages pour `top_p` sont supérieures à `0` et inférieures à `1`.
+ `temperature` : contrôle le degré de hasard du texte généré. Des valeurs plus élevées de `temperature` indiquent au modèle de générer des réponses plus aléatoires et plus diverses. Des valeurs plus faibles génèrent des réponses plus prévisibles. Les valeurs pour `temperature` doivent être positives.
+ `max_new_tokens` : limite la longueur de la réponse en limitant le nombre de jetons renvoyés par votre modèle. La valeur par défaut est `20` .
+ `decoder_input_details`— Renvoie des informations sur les probabilités logarithmiques attribuées par le modèle à chaque jeton suivant potentiel et au jeton IDs correspondant. Si `decoder_input_details` a pour valeur `True`, vous devez également définir `details` sur `True` pour recevoir les détails demandés. La valeur par défaut est `False` .
Pour plus d’informations sur les paramètres de ce modèle `Hugging Face`, consultez [types.py](https://github.com/huggingface/text-generation-inference/blob/v0.9.3/clients/python/text_generation/types.py#L8).
## Envoi d’un exemple de demande d’inférence
Pour tester votre modèle, envoyez un exemple de demande à votre modèle et affichez la réponse du modèle comme suit :
```
response = predictor.predict(payload)
print(response[0]["generated_text"])
```
Dans l’exemple de code précédent, si votre modèle a fourni la réponse `[{"response": "this is the output"}]`, l’instruction `print` renvoie `this is the output`.
## Configurez FMEval
1. Chargez les bibliothèques requises pour qu'elles s'exécutent FMEval comme suit :
```
import fmeval
from fmeval.data_loaders.data_config import DataConfig
from fmeval.model_runners.sm_jumpstart_model_runner import JumpStartModelRunner
from fmeval.constants import MIME_TYPE_JSONLINES
from fmeval.eval_algorithms.prompt_stereotyping import PromptStereotyping, PROMPT_STEREOTYPING
from fmeval.eval_algorithms import EvalAlgorithm
```
1. Configurez la configuration des données pour votre jeu de données d’entrée.
Si vous n’utilisez pas de jeu de données intégré, votre configuration de données doit identifier la colonne qui contient le plus de biais dans `sent_more_input_location`. Vous devez également identifier la colonne qui contient le moins de biais dans `sent_less_input_location`. Si vous utilisez un jeu de données intégré à partir de JumpStart, ces paramètres sont transmis FMEval automatiquement via les métadonnées du modèle.
Spécifiez les colonnes `sent_more_input_location` et `sent_less_input_location` pour une tâche de stéréotypage d’invite, le nom, l’identifiant de ressource uniforme (URI) et le type `MIME`.
```
config = DataConfig(
dataset_name="crows-pairs_sample",
dataset_uri="crows-pairs_sample.jsonl",
dataset_mime_type=MIME_TYPE_JSONLINES,
sent_more_input_location="sent_more",
sent_less_input_location="sent_less",
category_location="bias_type",
)
```
Pour plus d’informations sur les informations de colonne requises par d’autres tâches, consultez la section **Utilisation d’un jeu de données d’entrée personnalisé** dans [Utilisation d’un jeu de données d’entrée personnalisé](clarify-foundation-model-evaluate-auto-lib-custom.md#clarify-foundation-model-evaluate-auto-lib-custom-input).
1. Configurez un élément `ModelRunner` personnalisé dans l’exemple de code suivant :
```
js_model_runner = JumpStartModelRunner(
endpoint_name=endpoint_name,
model_id=model_id,
model_version=model_version,
output='[0].generated_text',
log_probability='[0].details.prefill[*].logprob',
content_template='{"inputs": $prompt, "parameters":
{"do_sample": true, "top_p": 0.9, "temperature": 0.8, "max_new_tokens": 1024,
"decoder_input_details": true,"details": true}}',
)
```
L’exemple de code précédent spécifie les éléments suivants :
+ `endpoint_name` : le nom du point de terminaison que vous avez créé dans l’étape précédente **Installation des bibliothèques requises**.
+ `model_id` : l’identifiant utilisé pour spécifier votre modèle. Ce paramètre a été spécifié lors de la définition du JumpStart modèle.
+ `model_version` : la version de votre modèle utilisée pour spécifier votre modèle. Ce paramètre a été spécifié lors de la définition du JumpStart modèle.
+ `output` : capture la sortie du [modèle Falcon 7b](https://huggingface.co/tiiuae/falcon-7b), qui renvoie sa réponse dans une clé `generated_text`. Si votre modèle a fourni la réponse `[{"generated_text": "this is the output"}]`, `[0].generated_text` renvoie `this is the output`.
+ `log_probability`— Capture la probabilité logarithmique renvoyée par ce JumpStart modèle.
+ `content_template` : spécifie la façon dont votre modèle interagit avec les demandes. L’exemple de modèle de configuration est détaillé uniquement pour expliquer l’exemple précédent, et il n’est pas obligatoire. Les paramètres du modèle de contenu sont les mêmes que ceux déclarés pour `payload`. Pour plus d’informations sur les paramètres de ce modèle `Hugging Face`, consultez [types.py](https://github.com/huggingface/text-generation-inference/blob/v0.9.3/clients/python/text_generation/types.py#L8).
1. Configurez votre rapport d’évaluation et enregistrez-le dans un répertoire comme indiqué dans l’exemple de code suivant :
```
import os
eval_dir = "results-eval-prompt-stereotyping"
curr_dir = os.getcwd()
eval_results_path = os.path.join(curr_dir, eval_dir) + "/"
os.environ["EVAL_RESULTS_PATH"] = eval_results_path
if os.path.exists(eval_results_path):
print(f"Directory '{eval_results_path}' exists.")
else:
os.mkdir(eval_results_path)
```
1. Configurez un facteur de parallélisation comme suit :
```
os.environ["PARALLELIZATION_FACTOR"] = "1"
```
`PARALLELIZATION_FACTOR` est un multiplicateur du nombre de lots simultanés envoyés à votre instance de calcul. Si votre matériel autorise la parallélisation, vous pouvez définir ce nombre pour multiplier le nombre d’invocations pour votre tâche d’évaluation. Par exemple, si vous avez `100` invocations et que `PARALLELIZATION_FACTOR` a pour valeur `2`, votre tâche exécutera `200` invocations. Vous pouvez augmenter `PARALLELIZATION_FACTOR` jusqu’à `10` ou supprimer complètement la variable. Pour lire un blog sur l'utilisation de AWS Lambda, `PARALLELIZATION_FACTOR` consultez la section Nouveaux [contrôles de dimensionnement AWS Lambda pour les sources d'événements Kinesis](https://aws.amazon.com/blogs/compute/new-aws-lambda-scaling-controls-for-kinesis-and-dynamodb-event-sources/) et DynamoDB.
## Exécution de votre évaluation de modèles
1. Définissez votre algorithme d’évaluation. L’exemple suivant montre comment définir un algorithme `PromptStereotyping` :
```
eval_algo = PromptStereotyping()
```
Pour des exemples d’algorithmes qui calculent des métriques pour d’autres tâches d’évaluation, consultez **Évaluation de votre modèle** dans [Utilisation de la bibliothèque `fmeval` pour exécuter une évaluation automatique](clarify-foundation-model-evaluate-auto-lib.md).
1. Exécutez votre algorithme d’évaluation. L’exemple de code suivant utilise le modèle et la configuration des données précédemment définis, ainsi qu’un élément `prompt_template` qui utilise `feature` pour transmettre votre invite au modèle comme suit :
```
eval_output = eval_algo.evaluate(model=js_model_runner, dataset_config=config,
prompt_template="$feature", save=True)
```
La sortie de votre modèle peut être différente de l’exemple de sortie précédent.
## Visualisation de vos résultats d’analyse
1. Analysez un rapport d’évaluation à partir de l’objet `eval_output` renvoyé par l’algorithme d’évaluation comme suit :
```
import json
print(json.dumps(eval_output, default=vars, indent=4))
```
La commande précédente renvoie la sortie suivante (condensée par souci de brièveté) :
```
[
{
"eval_name": "prompt_stereotyping",
"dataset_name": "crows-pairs_sample",
"dataset_scores": [
{
"name": "prompt_stereotyping",
"value": 0.6666666666666666
}
],
"prompt_template": "$feature",
"category_scores": [
{
"name": "disability",
"scores": [
{
"name": "prompt_stereotyping",
"value": 0.5
}
]
},
...
],
"output_path": "/home/sagemaker-user/results-eval-prompt-stereotyping/prompt_stereotyping_crows-pairs_sample.jsonl",
"error": null
}
]
```
L’exemple de sortie précédent affiche un score global pour le jeu de données suivant `"name": prompt_stereotyping`. Ce score est la différence normalisée des probabilités logarithmiques entre les réponses de modèle **plus** et moins biaisées. Si le score est supérieur à `0.5`, cela signifie que la réponse de votre modèle est plus susceptible de renvoyer une réponse plus biaisée. Si le score est inférieur à `0.5`, votre modèle est plus susceptible de renvoyer une réponse moins biaisée. Si le score est `0.5`, la réponse du modèle ne contient pas de biais tel que mesuré par le jeu de données d’entrée. Vous allez utiliser l’élément `output_path` pour créer un `Pandas` `DataFrame` à l’étape suivante.
1. Importez vos résultats et lisez-les dans un `DataFrame`, puis attachez les scores de stéréotypage d’invite à l’entrée du modèle, à la sortie du modèle et à la sortie cible comme suit :
```
import pandas as pd
data = []
with open(os.path.join(eval_results_path,
"prompt_stereotyping_crows-pairs_sample.jsonl"), "r") as file:
for line in file:
data.append(json.loads(line))
df = pd.DataFrame(data)
df['eval_algo'] = df['scores'].apply(lambda x: x[0]['name'])
df['eval_score'] = df['scores'].apply(lambda x: x[0]['value'])
df
```
Pour un bloc-notes contenant les exemples de code donnés dans cette section, voir [jumpstart-falcon-stereotyping.ipnyb](https://github.com/aws/fmeval/blob/main/examples/jumpstart-falcon-stereotyping.ipynb).
# Évaluation d’un modèle Amazon Bedrock pour l’exactitude de synthétisation de texte
Vous pouvez utiliser un `ModelRunner` wrapper de haut niveau pour créer une évaluation personnalisée basée sur un modèle hébergé en dehors de JumpStart.
Ce didacticiel explique comment charger le [modèle Anthropic Claude 2](https://www.anthropic.com/index/claude-2), qui est disponible dans Amazon Bedrock, et comment demander à ce modèle de résumer les invites textuelles. Ce didacticiel montre ensuite comment évaluer l’exactitude de la réponse du modèle à l’aide des métriques [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge), [https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor) et [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore).
Ce didacticiel montre comment effectuer les opérations suivantes :
+ Configurez votre environnement.
+ Exécution de votre évaluation de modèles
+ Visualisation de vos résultats d’analyse
## Configuration de votre environnement
**Conditions préalables**
+ Utilisez un environnement de noyau de base Python 3.10 et une instance `ml.m5.2xlarge` Amazon Elastic Compute Cloud (Amazon EC2) avant de commencer ce didacticiel.
Pour plus d’informations sur les types d’instances et leurs cas d’utilisation recommandés, consultez [Types d'instances disponibles pour une utilisation avec les blocs-notes Amazon SageMaker Studio Classic](notebooks-available-instance-types.md).
**Configuration d’Amazon Bedrock**
Avant de pouvoir utiliser un modèle Amazon Bedrock, vous devez demander l’accès à ce modèle.
1. Connectez-vous à votre Compte AWS.
1. Si vous n'avez pas de AWS compte, consultez [Créer un AWS compte](https://docs.aws.amazon.com/bedrock/latest/userguide/setting-up.html#sign-up-for-aws) dans **Configurer Amazon Bedrock**.
1. Ouvrez la [console Amazon Bedrock](https://console.aws.amazon.com/bedrock).
1. Dans la section **Bienvenue sur Amazon Bedrock \$1** qui s’ouvre, choisissez **Gérer l’accès aux modèles**.
1. Dans la section **Accéder aux modèles** qui apparaît, choisissez **Gérer l’accès aux modèles**.
1. Dans la section **Modèles de base** qui apparaît, cochez la case à côté de **Claude** dans la sous-section **Anthropic** de **Modèles**.
1. Choisissez **Demander l’accès au modèle**.
1. Si votre demande est acceptée, une coche indiquant **Accès accordé** devrait apparaître sous **Statut de l’accès** à côté du modèle sélectionné.
1. Vous devrez peut-être vous reconnecter Compte AWS à votre compte pour pouvoir accéder au modèle.
**Installation des bibliothèques requises**
1. Dans votre code, installez les bibliothèques `fmeval` et `boto3` comme suit :
```
!pip install fmeval
!pip3 install boto3==1.28.65
```
1. Importez les bibliothèques, définissez un facteur de parallélisation et invoquez un client Amazon Bedrock comme suit :
```
import boto3
import json
import os
# Dependent on available hardware and memory
os.environ["PARALLELIZATION_FACTOR"] = "1"
# Bedrock clients for model inference
bedrock = boto3.client(service_name='bedrock')
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
```
Dans l’exemple de code précédent, les points suivants s’appliquent :
+ `PARALLELIZATION_FACTOR` : multiplicateur du nombre de lots simultanés envoyés à votre instance de calcul. Si votre matériel autorise la parallélisation, vous pouvez définir ce nombre avec lequel multiplier le nombre d’invocations pour votre tâche d’évaluation. Par exemple, si vous avez `100` invocations et que `PARALLELIZATION_FACTOR` a pour valeur `2`, votre tâche exécutera `200` invocations. Vous pouvez augmenter `PARALLELIZATION_FACTOR` jusqu’à `10` ou supprimer complètement la variable. Pour lire un blog sur l'utilisation de AWS Lambda, `PARALLELIZATION_FACTOR` consultez la section Nouveaux [contrôles de dimensionnement Lambda pour les sources d'événements Kinesis](https://aws.amazon.com/blogs/compute/new-aws-lambda-scaling-controls-for-kinesis-and-dynamodb-event-sources/) et DynamoDB.
1. Téléchargez l’exemple de jeu de données `JSON Lines`, [sample-dataset.jsonl](https://github.com/aws/fmeval/blob/8da27af2f20369fd419c03d5bb0707ab24010b14/examples/xsum_sample.jsonl), dans votre répertoire de travail actuel.
1. Vérifiez que votre environnement contient l’exemple de fichier d’entrée suivant :
```
import glob
# Check for the built-in dataset
if not glob.glob("sample-dataset.jsonl"):
print("ERROR - please make sure file exists: sample-dataset.jsonl")
```
**Envoi d’un exemple de demande d’inférence à votre modèle**
1. Définissez le modèle et le type `MIME` de votre invite. Pour un [modèle Anthropic Claude 2](https://www.anthropic.com/index/claude-2) hébergé sur Amazon Bedrock, votre invite doit être structurée comme suit :
```
import json
model_id = 'anthropic.claude-v2'
accept = "application/json"
contentType = "application/json"
# Ensure that your prompt has the correct format
prompt_data = """Human: Who is Barack Obama?
Assistant:
"""
```
Pour plus d’informations sur la manière de structurer le corps de votre demande, consultez [Champ body de la demande d’invocation du modèle](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html#model-parameters-claude-request-body). Les autres modèles peuvent avoir des formats différents.
1. Envoyez un exemple de demande à votre modèle. Le corps de votre demande contient l’invite et tous les paramètres supplémentaires que vous souhaitez définir. Voici un exemple de demande avec `max_tokens_to_sample` défini sur `500` :
```
body = json.dumps({"prompt": prompt_data, "max_tokens_to_sample": 500})
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=contentType
)
response_body = json.loads(response.get("body").read())
print(response_body.get("completion"))
```
Dans l’exemple de code précédent, vous pouvez définir les paramètres suivants :
+ `temperature` : contrôle le degré de hasard du texte généré et accepte les valeurs positives. Des valeurs plus élevées de `temperature` indiquent au modèle de générer des réponses plus aléatoires et plus diverses. Des valeurs plus faibles génèrent des réponses plus prévisibles. Les plages de `temperature` sont comprises entre `0` et `1`, avec une valeur par défaut de 0,5.
+ `topP` : contrôle le degré de hasard en limitant l’ensemble de jetons à prendre en compte lors de la génération du jeton suivant. Des valeurs plus élevées de `topP` autorisent un ensemble contenant un vocabulaire plus large et des valeurs plus faibles limitent l’ensemble de jetons à des mots plus probables. Les plages de `topP` vont de `0` à `1`, avec une valeur par défaut de `1`.
+ `topK` : limite les prédictions modélisées aux `k` jetons les plus probables. Des valeurs plus élevées de `topK` permettent des réponses plus inventives. Des valeurs plus faibles génèrent des réponses plus cohérentes. Les plages de `topK` vont de `0` à `500`, avec une valeur par défaut de `250`.
+ `max_tokens_to_sample` : limite la longueur de la réponse en limitant le nombre de jetons renvoyés par votre modèle. Les plages de `max_tokens_to_sample` vont de `0` à `4096`, avec une valeur par défaut de `200`.
+ `stop_sequences` : spécifie une liste de séquences de caractères qui indiquent à votre modèle d’arrêter de générer une réponse. La sortie du modèle est arrêtée la première fois que l’une des chaînes répertoriées est rencontrée dans la sortie. La réponse ne contient pas la séquence d’arrêt. Par exemple, vous pouvez utiliser une séquence de retour chariot pour limiter la réponse du modèle à une seule ligne. Vous pouvez configurer jusqu’à `4` séquences d’arrêt.
Pour plus d’informations sur les paramètres que vous pouvez spécifier dans une demande, consultez [Modèles Anthropic Claude](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html).
**Configurez FMEval**
1. Chargez les bibliothèques requises pour qu'elles s'exécutent FMEval comme suit :
```
from fmeval.data_loaders.data_config import DataConfig
from fmeval.model_runners.bedrock_model_runner import BedrockModelRunner
from fmeval.constants import MIME_TYPE_JSONLINES
from fmeval.eval_algorithms.summarization_accuracy import SummarizationAccuracy, SummarizationAccuracyConfig
```
1. Configurez la configuration des données pour votre jeu de données d’entrée.
L’exemple d’entrée suivant se trouve à une ligne de `sample-dataset.jsonl` :
```
{
"document": "23 October 2015 Last updated at 17:44
BST\nIt's the highest rating a tropical storm
can get and is the first one of this magnitude
to hit mainland Mexico since 1959.\nBut how are
the categories decided and what do they mean?
Newsround reporter Jenny Lawrence explains.",
"summary": "Hurricane Patricia has been rated as
a category 5 storm.",
"id": "34615665",
}
```
L’exemple d’entrée précédent contient le texte à résumer dans la clé `document`. La référence par rapport à laquelle évaluer la réponse de votre modèle est dans la clé `summary`. Vous devez utiliser ces clés dans votre configuration de données pour spécifier les colonnes contenant les informations FMEval nécessaires à l'évaluation de la réponse du modèle.
Votre configuration de données doit identifier le texte que votre modèle doit résumer dans `model_input_location`. Vous devez identifier la valeur de référence avec `target_output_location`.
L’exemple de configuration de données suivant fait référence à l’exemple d’entrée précédent pour spécifier les colonnes requises pour une tâche de synthétisation de texte, le nom, l’identifiant de ressource uniforme (URI) et le type `MIME` :
```
config = DataConfig(
dataset_name="sample-dataset",
dataset_uri="sample-dataset.jsonl",
dataset_mime_type=MIME_TYPE_JSONLINES,
model_input_location="document",
target_output_location="summary"
)
```
Pour plus d’informations sur les informations de colonne requises pour d’autres tâches, consultez la section **Utilisation d’un jeu de données d’entrée personnalisé** dans [Évaluation automatique de modèles](clarify-foundation-model-evaluate-auto.md).
1. Configurez un élément `ModelRunner` personnalisé dans l’exemple de code suivant :
```
bedrock_model_runner = BedrockModelRunner(
model_id=model_id,
output='completion',
content_template='{"prompt": $prompt, "max_tokens_to_sample": 500}'
)
```
L’exemple de code précédent spécifie les éléments suivants :
+ `model_id` : l’identifiant utilisé pour spécifier votre modèle.
+ `output` : capture la sortie du modèle [Anthropic Claude 2](https://www.anthropic.com/index/claude-2), qui renvoie sa réponse dans une clé `completion`.
+ `content_template` : spécifie la façon dont votre modèle interagit avec les demandes. L’exemple de modèle de configuration est détaillé comme suit uniquement pour expliquer l’exemple précédent, et il n’est pas obligatoire.
+ Dans l’exemple `content_template` précédent, les points suivants s’appliquent :
+ La variable `prompt` spécifie l’invite d’entrée, qui capture la demande faite par l’utilisateur.
+ La variable `max_tokens_to_sample` spécifie le nombre maximal de jetons sur `500`, afin de limiter la longueur de la réponse.
Pour plus d’informations sur les paramètres que vous pouvez spécifier dans votre demande, consultez [Modèles Anthropic Claude](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html).
Le format du paramètre `content_template` dépend des entrées et des paramètres pris en charge par votre LLM. Dans ce didacticiel, le [modèle Claude 2 d’Anthropic](https://www.anthropic.com/index/claude-2) utilise l’élément `content_template` suivant :
```
"content_template": "{\"prompt\": $prompt, \"max_tokens_to_sample\": 500}"
```
Autre exemple, le [modèle Falcon 7b](https://huggingface.co/tiiuae/falcon-7b) peut prendre en charge l’élément `content_template` suivant :
```
"content_template": "{\"inputs\": $prompt, \"parameters\":{\"max_new_tokens\": \
10, \"top_p\": 0.9, \"temperature\": 0.8}}"
```
## Exécution de votre évaluation de modèles
**Définition et exécution de votre algorithme d’évaluation**
1. Définissez votre algorithme d’évaluation. L’exemple suivant montre comment définir un algorithme `SummarizationAccuracy`, qui est utilisé pour déterminer l’exactitude des tâches de synthétisation de texte :
```
eval_algo = SummarizationAccuracy(SummarizationAccuracyConfig())
```
Pour des exemples d’algorithmes qui calculent des métriques pour d’autres tâches d’évaluation, consultez **Évaluation de votre modèle** dans [Utilisation de la bibliothèque `fmeval` pour exécuter une évaluation automatique](clarify-foundation-model-evaluate-auto-lib.md).
1. Exécutez votre algorithme d’évaluation. L’exemple de code suivant utilise la configuration des données précédemment définie, ainsi qu’un élément `prompt_template` qui utilise les clés `Human` et `Assistant` :
```
eval_output = eval_algo.evaluate(model=bedrock_model_runner,
dataset_config=config,
prompt_template="Human: $feature\n\nAssistant:\n", save=True)
```
Dans l’exemple de code précédent, `feature` contient l’invite au format attendu par le modèle Amazon Bedrock.
## Visualisation de vos résultats d’analyse
1. Analysez un rapport d’évaluation à partir de l’objet `eval_output` renvoyé par l’algorithme d’évaluation comme suit :
```
# parse report
print(json.dumps(eval_output, default=vars, indent=4))
```
La commande précédente renvoie la sortie suivante :
```
[
{
"eval_name": "summarization_accuracy",
"dataset_name": "sample-dataset",
"dataset_scores": [
{
"name": "meteor",
"value": 0.2048823008681274
},
{
"name": "rouge",
"value": 0.03557697913367101
},
{
"name": "bertscore",
"value": 0.5406564395678671
}
],
"prompt_template": "Human: $feature\n\nAssistant:\n",
"category_scores": null,
"output_path": "/tmp/eval_results/summarization_accuracy_sample_dataset.jsonl",
"error": null
}
]
```
L’exemple de sortie précédent affiche les trois scores d’exactitude : [https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor), [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge) et [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore), l’élément `prompt_template` d’entrée, un élément `category_score` si vous en avez demandé un, les erreurs éventuelles et l’élément `output_path`. Vous allez utiliser l’élément `output_path` pour créer un `Pandas DataFrame` à l’étape suivante.
1. Importez vos résultats et lisez-les dans un `DataFrame`, puis attachez les scores d’exactitude à l’entrée du modèle, à la sortie du modèle et à la sortie cible comme suit :
```
import pandas as pd
data = []
with open("/tmp/eval_results/summarization_accuracy_sample_dataset.jsonl", "r") as file:
for line in file:
data.append(json.loads(line))
df = pd.DataFrame(data)
df['meteor_score'] = df['scores'].apply(lambda x: x[0]['value'])
df['rouge_score'] = df['scores'].apply(lambda x: x[1]['value'])
df['bert_score'] = df['scores'].apply(lambda x: x[2]['value'])
df
```
Dans cette invocation, l’exemple de code précédent renvoie la sortie suivante (contractée pour des raisons de concision) :
```
model_input model_output target_output prompt scores meteor_score rouge_score bert_score
0 John Edward Bates, formerly of Spalding, Linco... I cannot make any definitive judgments, as th... A former Lincolnshire Police officer carried o... Human: John Edward Bates, formerly of Spalding... [{'name': 'meteor', 'value': 0.112359550561797... 0.112360 0.000000 0.543234 ...
1 23 October 2015 Last updated at 17:44 BST\nIt'... Here are some key points about hurricane/trop... Hurricane Patricia has been rated as a categor... Human: 23 October 2015 Last updated at 17:44 B... [{'name': 'meteor', 'value': 0.139822692925566... 0.139823 0.017621 0.426529 ...
2 Ferrari appeared in a position to challenge un... Here are the key points from the article:\n\n... Lewis Hamilton stormed to pole position at the... Human: Ferrari appeared in a position to chall... [{'name': 'meteor', 'value': 0.283411142234671... 0.283411 0.064516 0.597001 ...
3 The Bath-born player, 28, has made 36 appearan... Okay, let me summarize the key points from th... Newport Gwent Dragons number eight Ed Jackson ... Human: The Bath-born player, 28, has made 36 a... [{'name': 'meteor', 'value': 0.089020771513353... 0.089021 0.000000 0.533514 ...
...
```
La sortie de votre modèle peut être différente de l’exemple de sortie précédent.
Pour un bloc-notes contenant les exemples de code donnés dans cette section, voir [bedrock-claude-summarization-accuracy.ipnyb](https://github.com/aws/fmeval/blob/main/examples/bedrock-claude-summarization-accuracy.ipynb).
## Blocs-notes supplémentaires
Le GitHub répertoire [fmeval](https://github.com/aws/fmeval/tree/main/examples) contient les exemples de blocs-notes supplémentaires suivants :
+ [bedrock-claude-factual-knowledge.ipnyb](https://github.com/aws/fmeval/blob/main/examples/bedrock-claude-factual-knowledge.ipynb) — Évalue un [modèle Anthropic Claude](https://www.anthropic.com/index/claude-2) 2 hébergé sur Amazon Bedrock pour en tirer des connaissances factuelles.
+ [byo-model-outputs.ipynb](https://github.com/aws/fmeval/blob/main/examples/byo-model-outputs.ipynb) — Évalue un [modèle Falcon7b](https://huggingface.co/tiiuae/falcon-7b) hébergé sur JumpStart des bases factuelles, dans lesquelles vous apportez vos propres résultats de modèle au lieu d'envoyer des demandes d'inférence à votre modèle.
+ [custom\$1model\$1runner\$1chat\$1gpt.ipnyb](https://github.com/aws/fmeval/blob/main/examples/custom_model_runner_chat_gpt.ipynb) : évalue un modèle `ChatGPT 3.5` personnalisé hébergé sur `Hugging Face` pour obtenir des connaissances factuelles.
# Résoudre les erreurs lors de la création d'une tâche d'évaluation de modèle dans Amazon SageMaker AI
**Important**
Pour utiliser les évaluations du modèle SageMaker Clarify Foundation (FMEval), vous devez passer à la nouvelle expérience Studio.
Depuis le 30 novembre 2023, l'expérience Amazon SageMaker Studio précédente s'appelle désormais Amazon SageMaker Studio Classic. FMEval n'est pas disponible dans Amazon SageMaker Studio Classic.
Pour en savoir plus sur la manière d’effectuer la mise à niveau vers la nouvelle expérience Studio, consultez [Migration depuis Amazon SageMaker Studio Classic](studio-updated-migrate.md). Pour en savoir plus sur l’utilisation de l’application Studio Classic, consultez [Amazon SageMaker Studio classique](studio.md).
Si vous rencontrez une erreur lors de la création d’une tâche d’évaluation de modèles, utilisez la liste suivante pour dépanner votre évaluation. Si vous avez besoin d'une assistance supplémentaire, [Support](https://console.aws.amazon.com/support/)contactez [AWS nos forums de développeurs pour Amazon SageMaker AI](https://forums.aws.amazon.com/forum.jspa?forumID=285).
**Rubriques**
+ [Erreur lors du chargement de vos données à partir d’un compartiment Amazon S3](#clarify-foundation-model-evaluate-troubleshooting-cors)
+ [Échec de la tâche de traitement](#clarify-foundation-model-evaluate-troubleshooting-failure)
+ [Vous ne trouvez pas d'évaluations de modèles de base dans la console d' SageMaker IA](#clarify-foundation-model-evaluate-troubleshooting-upgrade)
+ [Votre modèle ne prend pas en charge le stéréotypage d’invite](#clarify-foundation-model-evaluate-troubleshooting-ps)
+ [Erreurs de validation des jeux de données (humaines)](#clarify-foundation-model-evaluate-troubleshooting-valid)
## Erreur lors du chargement de vos données à partir d’un compartiment Amazon S3
Lorsque vous créez une évaluation de modèles de fondation, vous devez définir les autorisations appropriées pour le compartiment S3 dans lequel vous souhaitez stocker les entrées et sorties de votre modèle. Si les autorisations de partage de ressources entre origines (CORS) ne sont pas définies correctement, SageMaker AI génère l'erreur suivante :
Erreur : Impossible de placer l'objet dans s3 : erreur lors du téléchargement de l'objet vers S3 Erreur : échec de l'insertion de l'objet dans S3 : NetworkError lors de la tentative de récupération de la ressource.
Pour définir les autorisations de compartiment appropriées, suivez les instructions figurant sous **Configuration de votre environnement** dans [Création d’une tâche d’évaluation automatique de modèles dans Studio](clarify-foundation-model-evaluate-auto-ui.md).
## Échec de la tâche de traitement
Les raisons les plus courantes pour lesquelles votre tâche de traitement a échoué sont les suivantes :
+ [Quota insuffisant](#clarify-foundation-model-evaluate-troubleshooting-failure-quota)
+ [Mémoire insuffisante](#clarify-foundation-model-evaluate-troubleshooting-failure-memory)
+ [Échec lors de la vérification du ping](#clarify-foundation-model-evaluate-troubleshooting-failure-ping)
Consultez les sections suivantes pour découvrir comment atténuer chaque problème.
### Quota insuffisant
Lorsque vous effectuez une évaluation du modèle de base pour un JumpStart modèle non déployé, SageMaker Clarify déploie votre modèle linguistique étendu (LLM) sur un point de terminaison SageMaker AI de votre compte. Si le quota de votre compte n'est pas suffisant pour exécuter le JumpStart modèle sélectionné, la tâche échoue avec un`ClientError`. Pour augmenter votre quota, procédez comme suit :
**Demander une augmentation des Quotas de AWS Service**
1. Extrayez le nom de l’instance, le quota actuel et le quota nécessaire à partir du message d’erreur affiché à l’écran. Par exemple, pour l’erreur suivante :
+ Le nom de l’instance est `ml.g5.12xlarge`.
+ Le quota actuel à partir du nombre suivant `current utilization` est de `0 instances`
+ Le quota supplémentaire requis à partir du nombre suivant `request delta` est de `1 instances`.
Voici l’exemple d’erreur :
`ClientError: An error occurred (ResourceLimitExceeded) when calling the CreateEndpoint operation: The account-level service limit 'ml.g5.12xlarge for endpoint usage' is 0 Instances, with current utilization of 0 Instances and a request delta of 1 Instances. Please use AWS Service Quotas to request an increase for this quota. If AWS Service Quotas is not available, contact AWS support to request an increase for this quota`
1. Connectez-vous à la [console Service Quotas AWS Management Console et ouvrez-la](https://console.aws.amazon.com/servicequotas/home).
1. Dans le volet de navigation, sous **Gérer les quotas**, entrez **Amazon SageMaker AI**.
1. Choisissez **Afficher les quotas**.
1. Dans la barre de recherche, sous **Service Quotas**, saisissez le nom de l’instance de l’étape 1. Par exemple, en utilisant les informations contenues dans le message d’erreur de l’étape 1, entrez **ml.g5.12xlarge**.
1. Choisissez le **nom du quota** qui apparaît à côté du nom de votre instance et se termine par **pour l’utilisation de points de terminaison**. Par exemple, en utilisant les informations contenues dans le message d’erreur de l’étape 1, choisissez **ml.g5.12xlarge pour l’utilisation de points de terminaison**.
1. Choisissez **Demander une augmentation au niveau du compte**.
1. Sous **Augmenter la valeur du quota**, entrez le quota requis à partir des informations fournies dans le message d’erreur de l’étape 1. Entrez la **somme** de `current utilization` et `request delta`. Dans l’exemple d’erreur précédent, `current utilization` a pour valeur `0 Instances` et `request delta` a pour valeur `1 Instances`. Dans cet exemple, demandez un quota de `1` pour fournir le quota requis.
1. Cliquez sur **Demander**.
1. Choisissez **Historique des demandes de quotas** dans le volet de navigation.
1. Lorsque le **statut** passe de **En attente** à **Approuvé**, réexécutez votre tâche. Vous pouvez avoir besoin d’actualiser votre navigateur pour voir le changement.
Pour plus d’informations sur la manière de demander une augmentation de votre quota, consultez [Demande d’augmentation de quota](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html).
### Mémoire insuffisante
Si vous lancez une évaluation de modèles de fondation sur une instance Amazon EC2 qui ne dispose pas de suffisamment de mémoire pour exécuter un algorithme d’évaluation, la tâche échoue avec l’erreur suivante :
`The actor is dead because its worker process has died. Worker exit type: SYSTEM_ERROR Worker exit detail: Worker unexpectedly exits with a connection error code 2. End of file. There are some potential root causes. (1) The process is killed by SIGKILL by OOM killer due to high memory usage. (2) ray stop --force is called. (3) The worker is crashed unexpectedly due to SIGSEGV or other unexpected errors. The actor never ran - it was cancelled before it started running.`
Pour augmenter la mémoire disponible pour votre tâche d’évaluation, remplacez votre instance par une instance dotée de plus de mémoire. Si vous utilisez l’interface utilisateur, vous pouvez choisir un type d’instance sous **Configuration du processeur** à l’**étape 2**. Si vous exécutez votre tâche dans la console SageMaker AI, lancez un nouvel espace à l'aide d'une instance dotée d'une capacité de mémoire accrue.
Pour accéder à la liste des instance Amazon EC2, consultez [Types d’instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#AvailableInstanceTypes).
Pour plus d’informations sur les instances dotées d’une plus grande capacité de mémoire, consultez [Instances à mémoire optimisée](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/memory-optimized-instances.html).
### Échec lors de la vérification du ping
Dans certains cas, votre tâche d'évaluation du modèle de base échouera car elle n'a pas passé avec succès une vérification ping lors du déploiement de votre point de terminaison par l' SageMaker IA. Si elle ne réussit pas un test ping, l’erreur suivante apparaît :
`ClientError: Error hosting endpoint your_endpoint_name: Failed. Reason: The primary container for production variant AllTraffic did not pass the ping health check. Please check CloudWatch logs for this endpoint..., Job exited for model: your_model_name of model_type: your_model_type `
Si votre tâche génère cette erreur, attendez quelques minutes et exécutez à nouveau votre tâche. Si l'erreur persiste, contactez le [AWS Support](https://console.aws.amazon.com/support/) ou [les forums de AWS développeurs pour Amazon SageMaker AI](https://forums.aws.amazon.com/forum.jspa?forumID=285).
## Vous ne trouvez pas d'évaluations de modèles de base dans la console d' SageMaker IA
Pour utiliser les évaluations du modèle SageMaker Clarify Foundation, vous devez passer à la nouvelle expérience Studio. Depuis le 30 novembre 2023, l'expérience Amazon SageMaker Studio précédente s'appelle désormais Amazon SageMaker Studio Classic. La caractéristique d’évaluation des modèles de fondation ne peut être utilisée que dans l’expérience mise à jour. Pour en savoir plus sur la façon de mettre à jour Studio, consultez [Migration depuis Amazon SageMaker Studio Classic](studio-updated-migrate.md).
## Votre modèle ne prend pas en charge le stéréotypage d’invite
Seuls certains JumpStart modèles prennent en charge les stéréotypes rapides. Si vous sélectionnez un JumpStart modèle qui n'est pas pris en charge, le message d'erreur suivant apparaît :
`{"evaluationMetrics":"This model does not support Prompt stereotyping evaluation. Please remove that evaluation metric or select another model that supports it."}`
Si cette erreur s'affiche, vous ne pouvez pas utiliser le modèle que vous avez sélectionné dans le cadre d'une évaluation de base. SageMaker Clarify travaille actuellement à la mise à jour de tous les JumpStart modèles pour les tâches de stéréotypage rapides afin qu'ils puissent être utilisés dans une évaluation des modèles de base.
## Erreurs de validation des jeux de données (humaines)
Le jeu de données d’invite personnalisé d’une tâche d’évaluation de modèles qui utilise des employés humains doit être formaté au format des lignes JSON à l’aide de l’extension `.jsonl`.
Lorsque vous démarrez une tâche, chaque objet JSON du jeu de données d’invite est validé de manière interdépendante. Si l’un des objets JSON n’est pas valide, l’erreur suivante s’affiche.
```
Customer Error: Your input dataset could not be validated. Your dataset can have up to 1000 prompts. The dataset must be a valid jsonl file, and each prompt valid json object.To learn more about troubleshooting dataset validations errors, see Troubleshooting guide. Job executed for models: meta-textgeneration-llama-2-7b-f, pytorch-textgeneration1-alexa20b.
```
Pour qu’un jeu de données d’invite personnalisé réussisse toutes les validations, les conditions suivantes doivent être *vraies* pour tous les objets JSON du fichier de lignes JSON.
+ Chaque ligne du fichier de jeu de données d’invite doit être un objet JSON valide.
+ Les caractères spéciaux tels que les guillemets (`"`) doivent être correctement échappés. Par exemple, si votre invite était `"Claire said to the crowd, "Bananas are the best!""`, les guillemets devraient être échappés à l’aide d’une `\`, `"Claire said to the crowd, \"Bananas are the best!\""`.
+ Un objet JSON valide doit contenir au moins la paire clé/valeur `prompt`.
+ Un fichier de jeu de données d’invite ne peut pas contenir plus de 1 000 objets JSON dans un seul fichier.
+ Si vous spécifiez la clé `responses` dans un objet JSON *quelconque*, elle doit être présente dans *tous* les objets JSON.
+ Le nombre maximal d’objets dans la clé `responses` est 1. Si vous souhaitez comparer les réponses de plusieurs modèles, chacun nécessite un jeu de données BYOI distinct.
+ Si vous spécifiez la clé `responses` dans un objet JSON *quelconque*, il doit également contenir les clés `modelIdentifier` et `text` dans *tous* les objets `responses`.