Effectuez des transformations par lots avec les grands modèles de langage Amazon SageMaker Jumpstart Text2Text Generation | Services Web Amazon

Aujourd'hui, nous sommes ravis d'annoncer que vous pouvez désormais effectuer des transformations par lots avec Amazon SageMaker JumpStart grands modèles de langage (LLM) pour la génération Text2Text. Les transformations par lots sont utiles dans les situations où les réponses n'ont pas besoin d'être en temps réel et, par conséquent, vous pouvez effectuer une inférence par lots pour de grands ensembles de données en masse. Pour la transformation par lots, un travail par lots est exécuté qui prend l'entrée par lots comme un ensemble de données et un modèle pré-formé, et génère des prédictions pour chaque point de données dans l'ensemble de données. La transformation par lots est rentable car, contrairement aux points de terminaison hébergés en temps réel qui disposent d'un matériel persistant, les clusters de transformation par lots sont supprimés lorsque la tâche est terminée et, par conséquent, le matériel n'est utilisé que pendant la durée de la tâche par lots.

Dans certains cas d'utilisation, les demandes d'inférence en temps réel peuvent être regroupées en petits lots pour un traitement par lots afin de créer des réponses en temps réel ou en temps quasi réel. Par exemple, si vous avez besoin de traiter un flux continu de données avec une faible latence et un débit élevé, l'appel d'un point de terminaison en temps réel pour chaque demande séparément nécessiterait plus de ressources et peut prendre plus de temps pour traiter toutes les demandes car le traitement est effectué en série. . Une meilleure approche consisterait à regrouper certaines des demandes et à appeler le point de terminaison en temps réel en mode d'inférence par lots, qui traite vos demandes en une seule passe du modèle et renvoie la réponse en bloc pour la demande en temps réel ou en temps quasi réel. . La latence de la réponse dépendra du nombre de requêtes que vous regroupez et de la taille de la mémoire de l'instance. Vous pouvez donc régler la taille du lot en fonction des besoins de votre entreprise en matière de latence et de débit. Nous appelons cela inférence par lots en temps réel car il combine le concept de traitement par lots tout en fournissant des réponses en temps réel. Avec l'inférence par lots en temps réel, vous pouvez trouver un équilibre entre une faible latence et un débit élevé, ce qui vous permet de traiter de gros volumes de données de manière rapide et efficace.

La transformation par lots Jumpstart pour les modèles Text2Text Generation vous permet de transmettre les hyperparamètres par lots via des variables d'environnement qui augmentent encore le débit et minimisent la latence.

JumpStart fournit des modèles open source pré-entraînés pour un large éventail de types de problèmes afin de vous aider à démarrer avec l'apprentissage automatique (ML). Vous pouvez former et régler ces modèles de manière incrémentielle avant le déploiement. JumpStart fournit également des modèles de solution qui configurent l'infrastructure pour les cas d'utilisation courants, et des exemples de blocs-notes exécutables pour ML avec Amazon Sage Maker. Vous pouvez accéder aux modèles préformés, aux modèles de solution et aux exemples via la page d'accueil JumpStart dans Amazon SageMakerStudio. Vous pouvez également accéder aux modèles JumpStart à l'aide du SDK SageMaker Python.

Dans cet article, nous montrons comment utiliser l'état de l'art pré-formé text2text FLAN T5 modèles de Hugging Face pour la transformation par lots et l'inférence par lots en temps réel.

Vue d'ensemble de la solution

Le bloc-notes montrant la transformation par lots de modèles Text2Text FLAN T5 pré-formés à partir de Étreindre le visage dans disponible dans ce qui suit GitHub référentiel. Ce bloc-notes utilise les données de Hugging Face cnn_dailymail jeu de données pour une tâche de synthèse de texte à l'aide du SDK SageMaker.

Voici les étapes clés de la mise en œuvre de la transformation par lots et de l'inférence par lots en temps réel :

1. Configurez les prérequis.
2. Sélectionnez un modèle pré-formé.
3. Récupérer des artefacts pour le modèle.
4. Spécifiez les hyperparamètres de la tâche de transformation par lots.
5. Préparez les données pour la transformation par lots.
6. Exécutez la tâche de transformation par lots.
7. Évaluez le résumé à l'aide d'un ROUGE (Recall-Oriented Understudy for Gisting Evaluation).
8. Effectuez une inférence par lots en temps réel.

Configurer les prérequis

Avant d'exécuter le notebook, vous devez effectuer quelques étapes de configuration initiales. Configurons le rôle d'exécution SageMaker afin qu'il dispose des autorisations nécessaires pour exécuter les services AWS en votre nom :

sagemaker_session = Session()
aws_role = sagemaker_session.get_caller_identity_arn()
aws_region = boto3.Session().region_name
sess = sagemaker.Session()

Sélectionnez un modèle pré-entraîné

Nous utilisons le modèle huggingface-text2text-flan-t5-large comme modèle par défaut. En option, vous pouvez récupérer la liste des modèles Text2Text disponibles sur JumpStart et choisir votre modèle préféré. Cette méthode offre un moyen simple de sélectionner différents ID de modèle à l'aide du même bloc-notes. À des fins de démonstration, nous utilisons le modèle huggingface-text2text-flan-t5-large :

model_id, model_version, = ( "huggingface-text2text-flan-t5-large", "*",
)

Récupérer des artefacts pour le modèle

Avec SageMaker, nous pouvons effectuer une inférence sur le modèle pré-formé, même sans l'ajuster d'abord sur un nouvel ensemble de données. On commence par récupérer le deploy_image_uri, deploy_source_uriet une model_uri pour le modèle pré-entraîné :

inference_instance_type = "ml.p3.2xlarge" # Retrieve the inference docker container uri. This is the base HuggingFace container image for the default model above.
deploy_image_uri = image_uris.retrieve(
region=None,
framework=None, # automatically inferred from model_id
image_scope="inference",
model_id=model_id,
model_version=model_version,
instance_type=inference_instance_type,
) # Retrieve the model uri.
model_uri = model_uris.retrieve(
model_id=model_id, model_version=model_version, model_scope="inference"
) #Create the SageMaker model instance
model = Model(
image_uri=deploy_image_uri,
model_data=model_uri,
role=aws_role,
predictor_cls=Predictor)

Spécifier les hyperparamètres de la tâche de transformation par lots

Vous pouvez transmettre n'importe quel sous-ensemble d'hyperparamètres en tant que variables d'environnement à la tâche de transformation par lots. Vous pouvez également transmettre ces hyperparamètres dans une charge utile JSON. Toutefois, si vous définissez des variables d'environnement pour des hyperparamètres comme le montre le code suivant, les hyperparamètres avancés des exemples individuels dans la charge utile des lignes JSON ne seront pas utilisés. Si vous souhaitez utiliser des hyperparamètres de la charge utile, vous pouvez définir le hyper_params_dict paramètre comme null à la place.

#Specify the Batch Job Hyper Params Here, If you want to treate each example hyperparameters different please pass hyper_params_dict as None
hyper_params = {"batch_size":4, "max_length":50, "top_k": 50, "top_p": 0.95, "do_sample": True}
hyper_params_dict = {"HYPER_PARAMS":str(hyper_params)}

Préparer les données pour la transformation par lots

Nous sommes maintenant prêts à charger le cnn_dailymail ensemble de données de Hugging Face :

cnn_test = load_dataset('cnn_dailymail','3.0.0',split='test')

Nous passons en revue chaque saisie de données et créons les données d'entrée dans le format requis. Nous créons un articles.jsonl fichier en tant que fichier de données de test contenant des articles qui doivent être résumés en tant que charge utile d'entrée. Lorsque nous créons ce fichier, nous ajoutons l'invite "Briefly summarize this text:" à chaque ligne d'entrée de test. Si vous souhaitez disposer d'hyperparamètres différents pour chaque entrée de test, vous pouvez ajouter ces hyperparamètres dans le cadre de la création de l'ensemble de données.

Nous créons highlights.jsonl en tant que fichier de vérité terrain contenant les faits saillants de chaque article stocké dans le fichier de test articles.jsonl. Nous stockons les deux fichiers de test dans un Service de stockage simple Amazon (Amazon S3). Voir le code suivant :

#You can specify a prompt here
prompt = "Briefly summarize this text: "
#Provide the test data and the ground truth file name
test_data_file_name = "articles.jsonl"
test_reference_file_name = 'highlights.jsonl' test_articles = []
test_highlights =[] # We will go over each data entry and create the data in the input required format as described above
for id, test_entry in enumerate(cnn_test): article = test_entry['article'] highlights = test_entry['highlights'] # Create a payload like this if you want to have different hyperparameters for each test input # payload = {"id": id,"text_inputs": f"{prompt}{article}", "max_length": 100, "temperature": 0.95} # Note that if you specify hyperparameter for each payload individually, you may want to ensure that hyper_params_dict is set to None instead payload = {"id": id,"text_inputs": f"{prompt}{article}"} test_articles.append(payload) test_highlights.append({"id":id, "highlights": highlights}) with open(test_data_file_name, "w") as outfile: for entry in test_articles: outfile.write("%sn" % json.dumps(entry)) with open(test_reference_file_name, "w") as outfile: for entry in test_highlights: outfile.write("%sn" % json.dumps(entry)) # Uploading the data s3 = boto3.client("s3")
s3.upload_file(test_data_file_name, output_bucket, os.path.join(output_prefix + "/batch_input/articles.jsonl"))

Exécuter la tâche de transformation par lots

Lorsque vous démarrez une tâche de transformation par lots, SageMaker lance les ressources de calcul nécessaires pour traiter les données, y compris les instances CPU ou GPU selon le type d'instance sélectionné. Au cours de la tâche de transformation par lots, SageMaker provisionne et gère automatiquement les ressources de calcul nécessaires pour traiter les données, y compris les instances, le stockage et les ressources réseau. Lorsque la tâche de transformation par lots est terminée, les ressources de calcul sont automatiquement nettoyées par SageMaker. Cela signifie que les instances et le stockage utilisés pendant la tâche sont arrêtés et supprimés, libérant des ressources et minimisant les coûts. Voir le code suivant :

# Creating the Batch transformer object
batch_transformer = model.transformer( instance_count=1, instance_type=inference_instance_type, output_path=s3_output_data_path, assemble_with="Line", accept="text/csv", max_payload=1, env = hyper_params_dict
) # Making the predications on the input data
batch_transformer.transform(s3_input_data_path, content_type="application/jsonlines", split_type="Line") batch_transformer.wait()

Voici un exemple d'enregistrement du articles.jsonl fichier d'essai. Notez que l'enregistrement dans ce fichier a un ID qui correspond à predict.jsonl enregistrements de fichier qui affiche un enregistrement résumé en tant que sortie du modèle Hugging Face Text2Text. De même, le fichier de vérité terrain a également un ID correspondant pour l'enregistrement de données. L'ID correspondant dans le fichier de test, le fichier de vérité terrain et le fichier de sortie permet de lier les enregistrements d'entrée aux enregistrements de sortie pour une interprétation facile des résultats.

Voici l'exemple d'enregistrement d'entrée fourni pour la synthèse :

{"id": 0, "text_inputs": "Briefly summarize this text: (CNN)The Palestinian Authority officially became the 123rd member of the International Criminal Court on Wednesday, a step that gives the court jurisdiction over alleged crimes in Palestinian territories. The formal accession was marked with a ceremony at The Hague, in the Netherlands, where the court is based. The Palestinians signed the ICC's founding Rome Statute in January, when they also accepted its jurisdiction over alleged crimes committed "in the occupied Palestinian territory, including East Jerusalem, since June 13, 2014." Later that month, the ICC opened a preliminary examination into the situation in Palestinian territories, paving the way for possible war crimes investigations against Israelis. As members of the court, Palestinians may be subject to counter-charges as well. Israel and the United States, neither of which is an ICC member, opposed the Palestinians' efforts to join the body. But Palestinian Foreign Minister Riad al-Malki, speaking at Wednesday's ceremony, said it was a move toward greater justice. "As Palestine formally becomes a State Party to the Rome Statute today, the world is also a step closer to ending a long era of impunity and injustice," he said, according to an ICC news release. "Indeed, today brings us closer to our shared goals of justice and peace." Judge Kuniko Ozaki, a vice president of the ICC, said acceding to the treaty was just the first step for the Palestinians. "As the Rome Statute today enters into force for the State of Palestine, Palestine acquires all the rights as well as responsibilities that come with being a State Party to the Statute. These are substantive commitments, which cannot be taken lightly," she said. Rights group Human Rights Watch welcomed the development. "Governments seeking to penalize Palestine for joining the ICC should immediately end their pressure, and countries that support universal acceptance of the court's treaty should speak out to welcome its membership," said Balkees Jarrah, international justice counsel for the group. "What's objectionable is the attempts to undermine international justice, not Palestine's decision to join a treaty to which over 100 countries around the world are members." In January, when the preliminary ICC examination was opened, Israeli Prime Minister Benjamin Netanyahu described it as an outrage, saying the court was overstepping its boundaries. The United States also said it "strongly" disagreed with the court's decision. "As we have said repeatedly, we do not believe that Palestine is a state and therefore we do not believe that it is eligible to join the ICC," the State Department said in a statement. It urged the warring sides to resolve their differences through direct negotiations. "We will continue to oppose actions against Israel at the ICC as counterproductive to the cause of peace," it said. But the ICC begs to differ with the definition of a state for its purposes and refers to the territories as "Palestine." While a preliminary examination is not a formal investigation, it allows the court to review evidence and determine whether to investigate suspects on both sides. Prosecutor Fatou Bensouda said her office would "conduct its analysis in full independence and impartiality." The war between Israel and Hamas militants in Gaza last summer left more than 2,000 people dead. The inquiry will include alleged war crimes committed since June. The International Criminal Court was set up in 2002 to prosecute genocide, crimes against humanity and war crimes. CNN's Vasco Cotovio, Kareem Khadder and Faith Karimi contributed to this report."}

Voici la sortie prévue avec récapitulatif :

{'id': 0, 'generated_texts': ['The Palestinian Authority officially became a member of the International Criminal Court on Wednesday, a step that gives the court jurisdiction over alleged crimes in Palestinian territories.']}

Voici le résumé de la vérité terrain à des fins d'évaluation du modèle :

{"id": 0, "highlights": "Membership gives the ICC jurisdiction over alleged crimes committed in Palestinian territories since last June .nIsrael and the United States opposed the move, which could open the door to war crimes investigations against Israelis ."}

Ensuite, nous utilisons la vérité terrain et les résultats prédits pour l'évaluation du modèle.

Évaluer le modèle à l'aide d'un score ROUGE¶

ROUGE, ou Recall-Oriented Understudy for Gisting Evaluation, est un ensemble de métriques et un progiciel utilisé pour évaluer la synthèse automatique et la traduction automatique dans le traitement du langage naturel. Les métriques comparent un résumé ou une traduction produit automatiquement à un résumé ou une traduction de référence (produite par l'homme) ou à un ensemble de références.

Dans le code suivant, nous combinons les résumés prédits et originaux en les joignant sur la clé commune id et utilisez ceci pour calculer le score ROUGE :

# Downloading the predictions
s3.download_file(
output_bucket, output_prefix + "/batch_output/" + "articles.jsonl.out", "predict.jsonl"
) with open('predict.jsonl', 'r') as json_file:
json_list = list(json_file) # Creating the prediction list for the dataframe
predict_dict_list = []
for predict in json_list:
if len(predict) > 1:
predict_dict = ast.literal_eval(predict)
predict_dict_req = {"id": predict_dict["id"], "prediction": predict_dict["generated_texts"][0]}
predict_dict_list.append(predict_dict_req) # Creating the predictions dataframe
predict_df = pd.DataFrame(predict_dict_list) test_highlights_df = pd.DataFrame(test_highlights) # Combining the predict dataframe with the original summarization on id to compute the rouge score
df_merge = test_highlights_df.merge(predict_df, on="id", how="left") rouge = evaluate.load('rouge')
results = rouge.compute(predictions=list(df_merge["prediction"]),references=list(df_merge["highlights"]))
print(results)
{'rouge1': 0.32749078992945646, 'rouge2': 0.126038645005132, 'rougeL': 0.22764277967933363, 'rougeLsum': 0.28162915746368966}

Effectuez une inférence par lots en temps réel

Ensuite, nous vous montrons comment exécuter une inférence par lots en temps réel sur le point de terminaison en fournissant les entrées sous forme de liste. Nous utilisons le même ID de modèle et le même ensemble de données que précédemment, sauf que nous prenons quelques enregistrements de l'ensemble de données de test et les utilisons pour appeler un point de terminaison en temps réel.

Le code suivant montre comment créer et déployer un point de terminaison en temps réel pour l'inférence par lots en temps réel :

from sagemaker.utils import name_from_base
endpoint_name = name_from_base(f"jumpstart-example-{model_id}")
# deploy the Model. Note that we need to pass Predictor class when we deploy model through Model class,
# for being able to run inference through the sagemaker API.
model_predictor = model.deploy( initial_instance_count=1, instance_type=inference_instance_type, predictor_cls=Predictor, endpoint_name=endpoint_name
)

Ensuite, nous préparons notre charge utile d'entrée. Pour cela, nous utilisons les données que nous avons préparées précédemment et extrayons les 10 premières entrées de test et ajoutons aux entrées de texte les hyperparamètres que nous souhaitons utiliser. Nous fournissons cette charge utile au temps réel invoke_endpoint. La charge utile de réponse est ensuite renvoyée sous la forme d'une liste de réponses. Voir le code suivant :

#Provide all the text inputs to the model as a list
text_inputs = [entry["text_inputs"] for entry in test_articles[0:10]] # The information about the different Parameters is provided above
payload = { "text_inputs": text_inputs, "max_length": 50, "num_return_sequences": 1, "top_k": 50, "top_p": 0.95, "do_sample": True, "batch_size": 4
} def query_endpoint_with_json_payload(encoded_json, endpoint_name):
client = boto3.client("runtime.sagemaker")
response = client.invoke_endpoint(
EndpointName=endpoint_name, ContentType="application/json", Body=encoded_json
)
return response query_response = query_endpoint_with_json_payload(
json.dumps(payload).encode("utf-8"), endpoint_name=endpoint_name
) def parse_response_multiple_texts(query_response):
model_predictions = json.loads(query_response["Body"].read())
return model_predictions generated_text_list = parse_response_multiple_texts(query_response)
print(*generated_text_list, sep='n')

Nettoyer

Après avoir testé le point de terminaison, assurez-vous de supprimer le point de terminaison d'inférence SageMaker et de supprimer le modèle pour éviter des frais.

Conclusion

Dans ce bloc-notes, nous avons effectué une transformation par lots pour présenter le modèle Hugging Face Text2Text Generator pour les tâches de synthèse. La transformation par lots est avantageuse pour obtenir des inférences à partir de grands ensembles de données sans nécessiter de point de terminaison persistant. Nous avons lié les enregistrements d'entrée avec des inférences pour faciliter l'interprétation des résultats. Nous avons utilisé le score ROUGE pour comparer le résumé des données de test avec le résumé généré par le modèle.

De plus, nous avons démontré l'inférence par lots en temps réel, où vous pouvez envoyer un petit lot de données à un point de terminaison en temps réel pour atteindre un équilibre entre la latence et le débit pour des scénarios tels que le streaming de données d'entrée. L'inférence par lots en temps réel permet d'augmenter le débit des requêtes en temps réel.

Essayez la transformation par lots avec les modèles Text2Text Generation dans SageMaker dès aujourd'hui et faites-nous part de vos commentaires !

À propos des auteurs

Hémant Singh est un ingénieur en apprentissage automatique avec une expérience dans Amazon SageMaker JumpStart et les algorithmes intégrés Amazon SageMaker. Il a obtenu sa maîtrise du Courant Institute of Mathematical Sciences et B.Tech de l'IIT Delhi. Il a de l'expérience dans le travail sur une gamme variée de problèmes d'apprentissage automatique dans le domaine du traitement du langage naturel, de la vision par ordinateur et de l'analyse de séries chronologiques.

Rachna Chadha est architecte principal de solutions AI/ML dans les comptes stratégiques chez AWS. Rachna est une optimiste qui croit que l'utilisation éthique et responsable de l'IA peut améliorer la société à l'avenir et apporter la prospérité économique et sociale. Dans ses temps libres, Rachna aime passer du temps avec sa famille, faire de la randonnée et écouter de la musique.

Dr Ashish Khetan est un scientifique appliqué senior avec les algorithmes intégrés d'Amazon SageMaker et aide à développer des algorithmes d'apprentissage automatique. Il a obtenu son doctorat à l'Université de l'Illinois à Urbana-Champaign. Il est un chercheur actif en apprentissage automatique et en inférence statistique, et a publié de nombreux articles dans les conférences NeurIPS, ICML, ICLR, JMLR, ACL et EMNLP.

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• PlatoAiStream. Intelligence des données Web3. Connaissance Amplifiée. Accéder ici.
• Frapper l'avenir avec Adryenn Ashley. Accéder ici.
• Achetez et vendez des actions de sociétés PRE-IPO avec PREIPO®. Accéder ici.
• La source: https://aws.amazon.com/blogs/machine-learning/perform-batch-transforms-with-amazon-sagemaker-jumpstart-text2text-generation-large-language-models/