Realize transformações em lote com Amazon SageMaker Jumpstart Text2Text Generation modelos de linguagem grandes | Amazon Web Services

Hoje temos o prazer de anunciar que agora você pode realizar transformações em lote com JumpStart do Amazon SageMaker modelos de linguagem grande (LLMs) para Geração Text2Text. As transformações em lote são úteis em situações em que as respostas não precisam ser em tempo real e, portanto, você pode fazer inferência em lote para grandes conjuntos de dados em massa. Para a transformação em lote, é executado um trabalho em lote que usa a entrada em lote como um conjunto de dados e um modelo pré-treinado e gera previsões para cada ponto de dados no conjunto de dados. A transformação em lote é econômica porque, ao contrário dos endpoints hospedados em tempo real que possuem hardware persistente, os clusters de transformação em lote são desativados quando o trabalho é concluído e, portanto, o hardware é usado apenas durante o trabalho em lote.

Em alguns casos de uso, as solicitações de inferência em tempo real podem ser agrupadas em pequenos lotes para processamento em lote para criar respostas em tempo real ou quase em tempo real. Por exemplo, se você precisar processar um fluxo contínuo de dados com baixa latência e alta taxa de transferência, invocar um endpoint em tempo real para cada solicitação separadamente exigiria mais recursos e poderia levar mais tempo para processar todas as solicitações porque o processamento está sendo feito em série . Uma abordagem melhor seria agrupar algumas das solicitações e chamar o endpoint em tempo real no modo de inferência em lote, que processa suas solicitações em uma passagem direta do modelo e retorna a resposta em massa para a solicitação em tempo real ou quase em tempo real . A latência da resposta dependerá de quantas solicitações você agrupar e do tamanho da memória da instância, portanto, você pode ajustar o tamanho do lote de acordo com seus requisitos de negócios para latência e taxa de transferência. Nós chamamos isso inferência em lote em tempo real porque combina o conceito de lotes enquanto fornece respostas em tempo real. Com a inferência em lote em tempo real, você pode obter um equilíbrio entre baixa latência e alta taxa de transferência, permitindo processar grandes volumes de dados de maneira oportuna e eficiente.

A transformação em lote Jumpstart para modelos Text2Text Generation permite que você passe os hiperparâmetros em lote por meio de variáveis ​​de ambiente que aumentam ainda mais a taxa de transferência e minimizam a latência.

O JumpStart fornece modelos de código aberto pré-treinados para uma ampla variedade de tipos de problemas para ajudá-lo a começar a usar o aprendizado de máquina (ML). Você pode treinar e ajustar gradualmente esses modelos antes da implantação. O JumpStart também fornece modelos de solução que configuram a infraestrutura para casos de uso comuns e notebooks de exemplo executáveis ​​para ML com Amazon Sage Maker. Você pode acessar os modelos pré-treinados, modelos de solução e exemplos por meio da página inicial do JumpStart em Estúdio Amazon SageMaker. Você também pode acessar os modelos JumpStart usando o SageMaker Python SDK.

Neste post, demonstramos como usar o pré-treinado de última geração modelos text2text FLAN T5 de Hugging Face para transformação em lote e inferência em lote em tempo real.

Visão geral da solução

O notebook mostrando a transformação em lote de modelos Text2Text FLAN T5 pré-treinados de Abraçando o rosto disponível no seguinte Repositório GitHub. Este notebook usa dados do Hugging Face cnn_dailymail conjunto de dados para uma tarefa de resumo de texto usando o SageMaker SDK.

A seguir estão as principais etapas para implementar a transformação em lote e a inferência em lote em tempo real:

1. Configure os pré-requisitos.
2. Selecione um modelo pré-treinado.
3. Recupere artefatos para o modelo.
4. Especifique os hiperparâmetros da tarefa de transformação em lote.
5. Prepare os dados para a transformação em lote.
6. Execute a tarefa de transformação em lote.
7. Avalie o resumo usando um ROUGE (Recall-Oriented Understudy for Gisting Evaluation).
8. Realize inferência em lote em tempo real.

Pré-requisitos de configuração

Antes de executar o notebook, você deve concluir algumas etapas iniciais de configuração. Vamos configurar a função de execução do SageMaker para que ele tenha permissões para executar os serviços da AWS em seu nome:

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

Selecione um modelo pré-treinado

Usamos o modelo huggingface-text2text-flan-t5-large como modelo padrão. Opcionalmente, você pode recuperar a lista de modelos Text2Text disponíveis no JumpStart e escolher seu modelo preferido. Este método fornece uma maneira direta de selecionar diferentes IDs de modelo usando o mesmo notebook. Para fins de demonstração, usamos o modelo huggingface-text2text-flan-t5-large:

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

Recuperar artefatos para o modelo

Com o SageMaker, podemos realizar inferências no modelo pré-treinado, mesmo sem ajustá-lo primeiro em um novo conjunto de dados. Começamos recuperando o deploy_image_uri, deploy_source_uri e model_uri para o modelo pré-treinado:

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)

Especificar hiperparâmetros de tarefa de transformação em lote

Você pode passar qualquer subconjunto de hiperparâmetros como variáveis ​​de ambiente para a tarefa de transformação em lote. Você também pode passar esses hiperparâmetros em uma carga JSON. No entanto, se você estiver definindo variáveis ​​de ambiente para hiperparâmetros, como mostra o código a seguir, os hiperparâmetros avançados dos exemplos individuais na carga útil das linhas JSON não serão usados. Se você quiser usar hiperparâmetros da carga, você pode querer definir o hyper_params_dict parâmetro como nulo em vez disso.

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

Preparar dados para transformação em lote

Agora estamos prontos para carregar o cnn_dailymail conjunto de dados de Hugging Face:

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

Examinamos cada entrada de dados e criamos os dados de entrada no formato necessário. Nós criamos um articles.jsonl file como um arquivo de dados de teste contendo artigos que precisam ser resumidos como carga útil de entrada. À medida que criamos este arquivo, anexamos o prompt "Briefly summarize this text:" para cada linha de entrada de teste. Se você quiser ter diferentes hiperparâmetros para cada entrada de teste, poderá anexar esses hiperparâmetros como parte da criação do conjunto de dados.

Nós criamos highlights.jsonl como o arquivo de informações básicas contendo os destaques de cada artigo armazenado no arquivo de teste articles.jsonl. Armazenamos os dois arquivos de teste em um Serviço de armazenamento simples da Amazon (Amazon S3). Veja o seguinte código:

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

Execute o trabalho de transformação em lote

Quando você inicia um trabalho de transformação em lote, o SageMaker inicia os recursos de computação necessários para processar os dados, incluindo instâncias de CPU ou GPU, dependendo do tipo de instância selecionado. Durante o trabalho de transformação em lote, o SageMaker provisiona e gerencia automaticamente os recursos de computação necessários para processar os dados, incluindo instâncias, armazenamento e recursos de rede. Quando o trabalho de transformação em lote é concluído, os recursos de computação são limpos automaticamente pelo SageMaker. Isso significa que as instâncias e o armazenamento usados ​​durante o trabalho são interrompidos e removidos, liberando recursos e minimizando custos. Veja o seguinte código:

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

O seguinte é um registro de exemplo do articles.jsonl arquivo de teste. Observe que o registro neste arquivo tem um ID que corresponde a predict.jsonl registros de arquivo que mostram um registro resumido como saída do modelo Hugging Face Text2Text. Da mesma forma, o arquivo de informações básicas também possui um ID correspondente para o registro de dados. O ID correspondente no arquivo de teste, no arquivo de informações básicas e no arquivo de saída permite vincular registros de entrada com registros de saída para fácil interpretação dos resultados.

A seguir está o exemplo de registro de entrada fornecido para resumo:

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

A seguir está a saída prevista com resumo:

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

O seguinte é o resumo da verdade básica para fins de avaliação do modelo:

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

Em seguida, usamos a verdade básica e as saídas previstas para a avaliação do modelo.

Avalie o modelo usando uma pontuação ROUGE¶

ROUGE, ou Recall-Oriented Understudy for Gisting Evaluation, é um conjunto de métricas e um pacote de software usado para avaliar o resumo automático e a tradução automática no processamento de linguagem natural. As métricas comparam um resumo ou tradução produzido automaticamente com um resumo ou tradução de referência (produzida por humanos) ou um conjunto de referências.

No código a seguir, combinamos os resumos previsto e original juntando-os na chave comum id e use isso para calcular a pontuação 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}

Realize inferência em lote em tempo real

A seguir, mostramos como executar a inferência em lote em tempo real no endpoint, fornecendo as entradas como uma lista. Usamos o mesmo ID de modelo e conjunto de dados de antes, exceto que pegamos alguns registros do conjunto de dados de teste e os usamos para invocar um endpoint em tempo real.

O código a seguir mostra como criar e implantar um endpoint em tempo real para inferência em lote em tempo real:

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
)

Em seguida, preparamos nossa carga útil de entrada. Para isso, usamos os dados que preparamos anteriormente e extraímos as 10 primeiras entradas de teste e anexamos as entradas de texto com os hiperparâmetros que queremos usar. Nós fornecemos esta carga para o tempo real invoke_endpoint. A carga útil da resposta é então retornada como uma lista de respostas. Veja o seguinte código:

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

limpar

Depois de testar o endpoint, certifique-se de excluir o endpoint de inferência do SageMaker e excluir o modelo para evitar cobranças.

Conclusão

Neste notebook, realizamos uma transformação em lote para mostrar o modelo Hugging Face Text2Text Generator para tarefas de resumo. A transformação em lote é vantajosa na obtenção de inferências de grandes conjuntos de dados sem exigir um terminal persistente. Vinculamos registros de entrada com inferências para auxiliar na interpretação dos resultados. Usamos a pontuação ROUGE para comparar o resumo dos dados de teste com o resumo gerado pelo modelo.

Além disso, demonstramos a inferência em lote em tempo real, na qual você pode enviar um pequeno lote de dados para um endpoint em tempo real para obter um equilíbrio entre latência e taxa de transferência para cenários como dados de entrada de streaming. A inferência em lote em tempo real ajuda a aumentar a taxa de transferência para solicitações em tempo real.

Experimente a transformação em lote com modelos Text2Text Generation no SageMaker hoje e deixe-nos saber seus comentários!

Sobre os autores

Hemant Singh é um engenheiro de aprendizado de máquina com experiência nos algoritmos integrados Amazon SageMaker JumpStart e Amazon SageMaker. Ele obteve seu mestrado no Courant Institute of Mathematical Sciences e B.Tech no IIT Delhi. Ele tem experiência em trabalhar em diversos problemas de aprendizado de máquina no domínio do processamento de linguagem natural, visão computacional e análise de séries temporais.

Rachna Chadha é Arquiteto Principal de Soluções AI/ML em Contas Estratégicas na AWS. Rachna é uma otimista que acredita que o uso ético e responsável da IA ​​pode melhorar a sociedade no futuro e trazer prosperidade econômica e social. Em seu tempo livre, Rachna gosta de passar o tempo com sua família, fazer caminhadas e ouvir música.

Dr. é um cientista aplicado sênior com algoritmos integrados do Amazon SageMaker e ajuda a desenvolver algoritmos de aprendizado de máquina. Ele obteve seu PhD pela University of Illinois Urbana-Champaign. Ele é um pesquisador ativo em aprendizado de máquina e inferência estatística e publicou muitos artigos em conferências NeurIPS, ICML, ICLR, JMLR, ACL e EMNLP.

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoAiStream. Inteligência de Dados Web3. Conhecimento Amplificado. Acesse aqui.
• Cunhando o Futuro com Adryenn Ashley. Acesse aqui.
• Compre e venda ações em empresas PRE-IPO com PREIPO®. Acesse aqui.
• Fonte: https://aws.amazon.com/blogs/machine-learning/perform-batch-transforms-with-amazon-sagemaker-jumpstart-text2text-generation-large-language-models/