Voer batchtransformaties uit met Amazon SageMaker Jumpstart Text2Text Generation grote taalmodellen | Amazon-webservices

Vandaag zijn we verheugd aan te kondigen dat u nu batchtransformaties kunt uitvoeren met Amazon SageMaker JumpStart grote taalmodellen (LLM's) voor Text2Text Generation. Batchtransformaties zijn handig in situaties waarin de antwoorden niet in realtime hoeven te zijn en daarom kunt u in grote hoeveelheden inferentie in batch uitvoeren voor grote datasets. Voor batchtransformatie wordt een batchtaak uitgevoerd die batchinvoer als gegevensset en een vooraf getraind model gebruikt en voorspellingen uitvoert voor elk gegevenspunt in de gegevensset. Batchtransformatie is kosteneffectief omdat, in tegenstelling tot real-time gehoste eindpunten met permanente hardware, batchtransformatieclusters worden afgebroken wanneer de taak is voltooid en daarom wordt de hardware alleen gebruikt voor de duur van de batchtaak.

In sommige gebruikssituaties kunnen real-time inferentieverzoeken worden gegroepeerd in kleine batches voor batchverwerking om real-time of bijna real-time antwoorden te creëren. Als u bijvoorbeeld een continue gegevensstroom moet verwerken met een lage latentie en een hoge doorvoer, zou het aanroepen van een real-time eindpunt voor elk afzonderlijk verzoek meer middelen vereisen en kan het langer duren om alle verzoeken te verwerken omdat de verwerking serieel wordt uitgevoerd . Een betere benadering zou zijn om enkele verzoeken te groeperen en het real-time eindpunt aan te roepen in batch-inferentiemodus, die uw verzoeken verwerkt in één voorwaartse doorgang van het model en het bulkantwoord voor het verzoek in realtime of bijna realtime retourneert . De latentie van het antwoord is afhankelijk van het aantal verzoeken dat u groepeert en de geheugengrootte van de instantie. Daarom kunt u de batchgrootte afstemmen op uw zakelijke vereisten voor latentie en doorvoer. Wij noemen dit real-time batch-inferentie omdat het het concept van batching combineert en toch real-time reacties levert. Met real-time batch-inferentie kunt u een balans bereiken tussen lage latentie en hoge doorvoer, waardoor u grote hoeveelheden gegevens tijdig en efficiënt kunt verwerken.

Met Jumpstart-batchtransformatie voor Text2Text Generation-modellen kunt u de batch-hyperparameters doorgeven via omgevingsvariabelen die de doorvoer verder verhogen en latentie minimaliseren.

JumpStart biedt vooraf getrainde, open-source modellen voor een breed scala aan probleemtypes om u te helpen aan de slag te gaan met machine learning (ML). U kunt deze modellen stapsgewijs trainen en afstemmen voordat u ze implementeert. JumpStart biedt ook oplossingssjablonen voor het opzetten van een infrastructuur voor veelvoorkomende gebruiksscenario's, en uitvoerbare voorbeeldnotebooks voor ML met Amazon Sage Maker. U hebt toegang tot de vooraf getrainde modellen, oplossingssjablonen en voorbeelden via de JumpStart-landingspagina in Amazon SageMaker Studio. U kunt ook toegang krijgen tot JumpStart-modellen met behulp van de SageMaker Python SDK.

In dit bericht laten we zien hoe u de state-of-the-art pre-train gebruikt text2text FLAN T5-modellen van Hugging Face voor batchtransformatie en real-time batchinferentie.

Overzicht oplossingen

De notebook met batchtransformatie van vooraf getrainde Text2Text FLAN T5-modellen van Gezicht knuffelen beschikbaar in het volgende GitHub-repository. Dit notitieboek gebruikt gegevens van het knuffelende gezicht cnn_dagelijksemail dataset voor een tekstsamenvattingstaak met behulp van de SageMaker SDK.

Hieronder volgen de belangrijkste stappen voor het implementeren van batchtransformatie en real-time batchinferentie:

1. Stel voorwaarden in.
2. Selecteer een vooraf getraind model.
3. Artefacten voor het model ophalen.
4. Geef de hyperparameters van de batchtransformatietaak op.
5. Bereid gegevens voor op de batchtransformatie.
6. Voer de batchtransformatietaak uit.
7. Evalueer de samenvatting met a ROOD (Recall-Oriented Understudy for Gisting Evaluation) score.
8. Voer real-time batch-inferentie uit.

Vereisten instellen

Voordat u de notebook uitvoert, moet u enkele eerste installatiestappen uitvoeren. Laten we de uitvoeringsrol van SageMaker zo instellen dat deze machtigingen heeft om namens u AWS-services uit te voeren:

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

Selecteer een vooraf getraind model

We gebruiken het knuffelgezicht-tekst2tekst-vlaai-t5-groot model als standaardmodel. Optioneel kunt u de lijst met beschikbare Text2Text-modellen ophalen op JumpStart en uw voorkeursmodel kiezen. Deze methode biedt een eenvoudige manier om verschillende model-ID's te selecteren met dezelfde notebook. Voor demonstratiedoeleinden gebruiken we het knuffelgezicht-tekst2tekst-vlaai-t5-groot model:

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

Artefacten voor het model ophalen

Met SageMaker kunnen we gevolgtrekkingen maken op het vooraf getrainde model, zelfs zonder het eerst te verfijnen op een nieuwe dataset. We beginnen met het ophalen van de deploy_image_uri, deploy_source_uri en model_uri voor het vooraf getrainde model:

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)

Geef de hyperparameters van de batchtransformatietaak op

U kunt elke subset van hyperparameters als omgevingsvariabelen doorgeven aan de batchtransformatietaak. U kunt deze hyperparameters ook doorgeven in een JSON-payload. Als u echter omgevingsvariabelen instelt voor hyperparameters, zoals de volgende code laat zien, worden de geavanceerde hyperparameters van de afzonderlijke voorbeelden in de payload van JSON-regels niet gebruikt. Als u hyperparameters van de payload wilt gebruiken, kunt u het hyper_params_dict parameter als null in plaats daarvan.

#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)}

Gegevens voorbereiden voor batchtransformatie

Nu zijn we klaar om de cnn_dagelijksemail dataset van Hugging Face:

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

We nemen elke gegevensinvoer door en creëren de invoergegevens in het vereiste formaat. Wij creëren een articles.jsonl bestand als een testgegevensbestand met artikelen die moeten worden samengevat als invoerpayload. Terwijl we dit bestand maken, voegen we de prompt toe "Briefly summarize this text:" aan elke testinvoerrij. Als u voor elke testinvoer verschillende hyperparameters wilt hebben, kunt u die hyperparameters toevoegen als onderdeel van het maken van de dataset.

We creëren highlights.jsonl als het Ground Truth-bestand met hoogtepunten van elk artikel dat in het testbestand is opgeslagen articles.jsonl. We slaan beide testbestanden op in een Amazon eenvoudige opslagservice (Amazon S3) emmer. Zie de volgende code:

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

Voer de batchtransformatietaak uit

Wanneer u een batchtransformatietaak start, start SageMaker de benodigde rekenbronnen om de gegevens te verwerken, inclusief CPU- of GPU-instanties, afhankelijk van het geselecteerde instantietype. Tijdens de batchtransformatie levert en beheert SageMaker automatisch de rekenbronnen die nodig zijn om de gegevens te verwerken, inclusief instanties, opslag en netwerkbronnen. Wanneer de batchtransformatietaak is voltooid, worden de rekenbronnen automatisch opgeschoond door SageMaker. Dit betekent dat de instanties en opslag die tijdens de taak worden gebruikt, worden gestopt en verwijderd, waardoor resources worden vrijgemaakt en de kosten worden geminimaliseerd. Zie de volgende code:

# 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()

Het volgende is een voorbeeldrecord uit de articles.jsonl test bestand. Merk op dat het record in dit bestand een ID heeft die overeenkomt met predict.jsonl bestandsrecords die een samengevat record tonen als uitvoer van het Hugging Face Text2Text-model. Evenzo heeft het Ground Truth-bestand ook een overeenkomende ID voor het gegevensrecord. De overeenkomende ID in het testbestand, het Ground Truth-bestand en het uitvoerbestand maakt het mogelijk invoerrecords te koppelen aan uitvoerrecords voor eenvoudige interpretatie van de resultaten.

Het volgende is het voorbeeld van een invoerrecord voor samenvatting:

{"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."}

Het volgende is de voorspelde uitvoer met samenvatting:

{'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.']}

Het volgende is de samenvatting van de grondwaarheid voor modelevaluatiedoeleinden:

{"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 ."}

Vervolgens gebruiken we de grondwaarheid en voorspelde outputs voor modelevaluatie.

Evalueer het model met behulp van een ROUGE-score¶

ROOD, of Recall-Oriented Understudy for Gisting Evaluation, is een set metrieken en een softwarepakket dat wordt gebruikt voor het evalueren van automatische samenvatting en automatische vertaling bij natuurlijke taalverwerking. De statistieken vergelijken een automatisch geproduceerde samenvatting of vertaling met een referentie (door mensen geproduceerde) samenvatting of vertaling of een reeks referenties.

In de volgende code combineren we de voorspelde en originele samenvattingen door ze samen te voegen op de gemeenschappelijke sleutel id en gebruik dit om de ROUGE-score te berekenen:

# 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}

Voer real-time batch-inferentie uit

Vervolgens laten we u zien hoe u real-time batchgevolgtrekking op het eindpunt kunt uitvoeren door de invoer als een lijst op te geven. We gebruiken dezelfde model-ID en dataset als eerder, behalve dat we een paar records uit de testdataset nemen en deze gebruiken om een ​​real-time eindpunt aan te roepen.

De volgende code laat zien hoe u een real-time eindpunt maakt en implementeert voor real-time batch-inferentie:

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
)

Vervolgens bereiden we onze input-payload voor. Hiervoor gebruiken we de gegevens die we eerder hebben voorbereid en extraheren we de eerste 10 testinvoer en voegen we de tekstinvoer toe met hyperparameters die we willen gebruiken. We leveren deze payload aan de real-time invoke_endpoint. De payload van het antwoord wordt vervolgens geretourneerd als een lijst met antwoorden. Zie de volgende code:

#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')

Opruimen

Nadat u het eindpunt hebt getest, moet u ervoor zorgen dat u het SageMaker-inferentie-eindpunt en het model verwijdert om te voorkomen dat er kosten in rekening worden gebracht.

Conclusie

In dit notitieboek hebben we een batchtransformatie uitgevoerd om het Hugging Face Text2Text Generator-model voor samenvattingstaken te demonstreren. Batchtransformatie is voordelig bij het verkrijgen van gevolgtrekkingen uit grote datasets zonder dat een persistent eindpunt vereist is. We hebben invoerrecords gekoppeld aan gevolgtrekkingen om te helpen bij de interpretatie van resultaten. We hebben de ROUGE-score gebruikt om de samenvatting van de testgegevens te vergelijken met de door het model gegenereerde samenvatting.

Daarnaast hebben we realtime batch-inferentie gedemonstreerd, waarbij u een kleine batch gegevens naar een real-time eindpunt kunt sturen om een ​​evenwicht te bereiken tussen latentie en doorvoer voor scenario's zoals het streamen van invoergegevens. Realtime batch-inferentie helpt de verwerkingscapaciteit van realtime verzoeken te verhogen.

Probeer vandaag nog de batchtransformatie uit met Text2Text Generation-modellen in SageMaker en laat ons uw feedback weten!

Over de auteurs

Heman Singh is een Machine Learning Engineer met ervaring in Amazon SageMaker JumpStart en Amazon SageMaker ingebouwde algoritmen. Hij behaalde zijn masters aan het Courant Institute of Mathematical Sciences en B.Tech aan IIT Delhi. Hij heeft ervaring met het werken aan uiteenlopende machine learning-problemen binnen het domein van natuurlijke taalverwerking, computervisie en tijdreeksanalyse.

Rachna Chadha is een Principal Solutions Architect AI/ML in Strategic Accounts bij AWS. Rachna is een optimist die gelooft dat het ethische en verantwoorde gebruik van AI de samenleving in de toekomst kan verbeteren en economische en sociale welvaart kan brengen. In haar vrije tijd brengt Rachna graag tijd door met haar gezin, wandelen en naar muziek luisteren.

Dr Ashish Khetan is een Senior Applied Scientist met ingebouwde algoritmen van Amazon SageMaker en helpt bij het ontwikkelen van algoritmen voor machine learning. Hij promoveerde aan de Universiteit van Illinois in Urbana-Champaign. Hij is een actief onderzoeker op het gebied van machine learning en statistische inferentie, en heeft veel artikelen gepubliceerd op NeurIPS-, ICML-, ICLR-, JMLR-, ACL- en EMNLP-conferenties.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoAiStream. Web3 gegevensintelligentie. Kennis versterkt. Toegang hier.
• De toekomst slaan met Adryenn Ashley. Toegang hier.
• Koop en verkoop aandelen in PRE-IPO-bedrijven met PREIPO®. Toegang hier.
• Bron: https://aws.amazon.com/blogs/machine-learning/perform-batch-transforms-with-amazon-sagemaker-jumpstart-text2text-generation-large-language-models/