Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # É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. Ce didacticiel montre ensuite comment évaluer les réponses aux stéréotypes rapides par rapport à l'ensemble de données de défis [CrowS-Pairs](https://github.com/nyu-mll/crows-pairs)open source 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\_sample.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 aux identifiants de jetons correspondants. 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`. ## Configuration de FMEval 1. Chargez les bibliothèques requises pour exécuter 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 automatiquement à FMeval 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 [Utilisez 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, consultez [jumpstart-falcon-stereotyping.ipnyb](https://github.com/aws/fmeval/blob/main/examples/jumpstart-falcon-stereotyping.ipynb).