Évaluer un modèle Amazon Bedrock pour la précision du résumé du texte

Prérequis

• Utiliser une base Python 3.10 environnement de noyau et instance ml.m5.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.

Configuration d’Amazon Bedrock

Avant de pouvoir utiliser un modèle Amazon Bedrock, vous devez demander l'accès à celui-ci.

1. Connectez-vous à votre Compte 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 le Welcome to Amazon Bedrock ! dans la section qui s'ouvre, choisissez Gérer l'accès aux modèles.

4. Dans la section Accès au modèle qui apparaît, choisissez Gérer l'accès au modèle.

5. Dans la section Modèles de base qui apparaît, cochez la case à côté de Claude dans la sous-section Anthropic des modèles.

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

7. Si votre demande est acceptée, une coche indiquant que l'accès est accordé devrait apparaître sous État 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 boto3 bibliothèques fmeval et comme suit :

   !pip install fmeval
   !pip3 install boto3==1.28.65

2. Importez des bibliothèques, définissez un facteur de parallélisation et appelez 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 règles suivantes s'appliquent :

   • PARALLELIZATION_FACTOR— Un multiplicateur pour le 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. 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 Lambda pour les sources d'événements Kinesis et DynamoDB.

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

4. Vérifiez que votre environnement contient l'exemple de fichier d'entrée comme suit :

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

Envoyez un exemple de demande d'inférence à votre modèle

1. Définissez le modèle et le MIME type de votre message. Pour un modèle Anthropic Claude 2 hébergé sur Amazon Bedrock, votre message doit être structuré 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 le champ Modèle de corps de demande d'invocation. Les autres modèles peuvent avoir des formats différents.

2. Envoyez une demande d'échantillon à votre modèle. Le corps de votre demande contient l'invite et tous les paramètres supplémentaires que vous souhaitez définir. Un exemple de demande max_tokens_to_sample défini 500 comme suit :

   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 caractère aléatoire du texte généré et accepte les valeurs positives. 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 plages temperature sont comprises entre 0 et1, avec une valeur par défaut de 0,5.

   • topP— 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 topP autorisent un ensemble contenant un vocabulaire plus large et des valeurs faibles limitent l'ensemble de jetons à des mots plus probables. Les plages pour topP vont 0 de à1, avec une valeur par défaut de1.

   • topK— Limite les prédictions du modèle aux jetons k les plus probables. Des valeurs plus élevées topK permettent des réponses plus inventives. Des valeurs faibles génèrent des réponses plus cohérentes. Les plages pour topK vont 0 de à500, avec une valeur par défaut de250.

   • 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 pour max_tokens_to_sample vont 0 de à4096, avec une valeur par défaut de200.

   • 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 de chariot pour limiter la réponse du modèle à une seule ligne. Vous pouvez configurer jusqu'à des séquences d'4arrêt.

   Pour plus d'informations sur les paramètres que vous pouvez spécifier dans une demande, consultez la section Modèles Anthropic Claude.

Configurez FMEval

1. Chargez les bibliothèques requises pour les exécuter 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 en 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 à l'intérieur de la document clé. La référence par rapport à laquelle évaluer la réponse de votre modèle est summary essentielle. 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 dans lequel votre modèle doit être résumémodel_input_location. Vous devez identifier la valeur de référence avectarget_output_location.

   L'exemple de configuration de données suivant fait référence à l'exemple de saisie précédent pour spécifier les colonnes requises pour une tâche de synthèse de texte, le nom, l'identifiant de ressource uniforme (URI) et le MIME type :

   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 les autres tâches, consultez la section Utiliser un jeu de données d'entrée personnalisé dansÉvaluation automatique du modèle.

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

   • model_id— L'identifiant utilisé pour spécifier votre modèle.

   • output— Capture le résultat du modèle Anthropic Claude 2, qui renvoie sa réponse sous forme de completion clé.

   • 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é comme suit uniquement pour expliquer l'exemple précédent, et il n'est pas obligatoire.

     • Dans l'content_templateexemple précédent, les conditions suivantes s'appliquent :

       • La variable prompt spécifie l'invite de saisie, qui capture la demande faite par l'utilisateur.

       • La variable max_tokens_to_sample indique le nombre maximum de jetons à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 les modèles Anthropic Claude.

       Le format du content_template paramètre dépend des entrées et des paramètres pris en charge par votreLLM. Dans ce didacticiel, le modèle Claude 2 d'Anthropic utilise les éléments suivants : content_template

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

       Autre exemple, le modèle Falcon7b peut prendre en charge les éléments suivants : content_template

       "content_template": "{\"inputs\": $prompt, \"parameters\":{\"max_new_tokens\": \
       10, \"top_p\": 0.9, \"temperature\": 0.8}}"

Définissez et exécutez votre algorithme d'évaluation

1. Définissez votre algorithme d'évaluation. L'exemple suivant montre comment définir un SummarizationAccuracy algorithme, qui est utilisé pour déterminer la précision des tâches de synthèse de texte :

   eval_algo = SummarizationAccuracy(SummarizationAccuracyConfig())

   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 la configuration de données précédemment définie et un prompt_template qui utilise les Assistant touches Human et :

   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'eval_outputobjet 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 le résultat suivant :

   [
   {
       "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 de précision : Meteor, Rouge, et BERTScore, la saisieprompt_template, un category_score si vous en avez demandé une, les erreurs éventuelles, et leoutput_path. 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 précision à 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 cet appel, 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.