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

Prérequis

• Utiliser une base Python 3.10 environnement de noyau et instance ml.g4dn.2xlarge Amazon Elastic Compute Cloud (AmazonEC2) avant de commencer ce didacticiel.

  Pour plus d'informations sur les types d'instances et leurs cas d'utilisation recommandés, consultezTypes d'instances disponibles pour une utilisation avec Studio Classic.

Installation des bibliothèques requises

1. Installez les bibliothèques SageMakerfmeval, et 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 JSON Lines données 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 de la charge utile, 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) lors de l'inférence du 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 surTrue, vous devez spécifier une valeur pour l'un des paramètres suivants : temperaturetop_k,top_p, outypical_p.

   • top_p— Contrôle le caractère aléatoire en limitant l'ensemble de jetons à prendre en compte lors de la génération du jeton suivant. Des valeurs plus élevées top_p permettent d'obtenir un ensemble contenant un vocabulaire plus large. Les valeurs 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 caractère aléatoire du texte généré. Des valeurs plus élevées temperature indiquent au modèle de générer des réponses plus aléatoires et plus diverses. Des valeurs 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 ce paramètre est défini surTrue, vous devez également True le configurer details pour recevoir les informations demandées. La valeur par défaut est False.

   Pour plus d'informations sur les paramètres de ce Hugging Face modèle, consultez le fichier types.py.

1. Chargez les bibliothèques requises pour les 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

2. Configurez la configuration des données pour votre jeu de données en 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 biaissent_more_input_location. Vous devez également identifier la colonne qui contient le moins de biaissent_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 sent_less_input_location colonnes sent_more_input_location et pour une tâche de stéréotypage rapide, le nom, l'identifiant de ressource uniforme (URI) et le MIME type.

   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 Utiliser un jeu de données d'entrée personnalisé dansUtiliser un jeu de données d'entrée personnalisé.

3. Configurez une personnalisation ModelRunner comme indiqué 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 indique ce qui suit :

   • endpoint_name— Le nom du point de terminaison que vous avez créé lors de l'étape précédente d'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 Falcon7b, qui renvoie sa réponse sous forme de clé. generated_text Si votre modèle a fourni la réponse[{"generated_text": "this is the output"}], il est [0].generated_text renvoyéthis is the output.

   • log_probability— Capture la probabilité logarithmique renvoyée par ce JumpStart modèle.

   • content_template— Spécifie la manière 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 pourpayload. Pour plus d'informations sur les paramètres de ce Hugging Face modèle, consultez le fichier 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"

   A 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'appels pour votre tâche d'évaluation. Par exemple, si vous avez des 100 invocations et que la valeur PARALLELIZATION_FACTOR est définie sur2, votre tâche 200 exécutera des invocations. Vous pouvez PARALLELIZATION_FACTOR augmenter 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 PromptStereotyping algorithme :

   eval_algo = PromptStereotyping()

   Pour des exemples d'algorithmes qui calculent des métriques pour d'autres tâches d'évaluation, voir Évaluer votre modèle dansUtiliser la fmeval bibliothèque 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 prompt_template qu'un modèle qui permet de feature 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'eval_outputobjet 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 le résultat suivant (condensé par souci de concision) :

   [
   {
       "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 l'ensemble de données suivant"name": prompt_stereotyping. Ce score est la différence normalisée des probabilités logarithmiques entre la réponse du modèle fournissant plus ou moins de biais. 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 contenant moins de biais. Si le score est le cas0.5, la réponse du modèle ne contient pas de biais tel que mesuré par le jeu de données en entrée. Vous allez utiliser le output_path pour créer un Pandas DataFrame à l'étape suivante.

2. Importez vos résultats et lisez-les dans un fichierDataFrame, puis associez les scores de stéréotypage rapides à 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.