Évaluation d’un modèle Amazon Bedrock pour l’exactitude de synthétisation de texte

Conditions préalables

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

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 à votreCompte AWS.

   1. Si vous n'avez pas de AWS compte, consultez Créer un AWS compte dans Configurer Amazon Bedrock.

2. Ouvrez la console Amazon Bedrock.

3. Dans la section Bienvenue sur Amazon Bedrock ! qui s’ouvre, choisissez Gérer l’accès aux modèles.

4. Dans la section Accéder aux modèles qui apparaît, choisissez Gérer l’accès aux modèles.

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

6. Choisissez Demander l’accès au modèle.

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

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

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

3. Téléchargez l’exemple de jeu de données JSON Lines, sample-dataset.jsonl, dans votre répertoire de travail actuel.

4. 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 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. Les autres modèles peuvent avoir des formats différents.

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

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

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

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

       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 utilise l’élément content_template suivant :

          "content_template": "{\"prompt\": $prompt, \"max_tokens_to_sample\": 500}"

       Autre exemple, le modèle 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}}"

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.

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

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 : Meteor, Rouge et 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.

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