Évaluer un JumpStart modèle permettant de créer rapidement des stéréotypes

Conditions préalables

• Utilisez un environnement de noyau Python 3.10 de base 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.

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

2. Téléchargez l’exemple de jeu de données JSON Lines crows-pairs_sample.jsonl, dans votre répertoire de travail actuel.

3. 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")
                       

4. Définissez un JumpStart modèle comme suit :

   from sagemaker.jumpstart.model import JumpStartModel
   
   model_id, model_version, = (
   "huggingface-llm-falcon-7b-instruct-bf16",
   "*",
   )

5. 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

6. 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.

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

2. 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é.

3. 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, 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.

4. 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)

5. 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 et DynamoDB.

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.

2. 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.

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.

2. 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.