Realice transformaciones por lotes con Amazon SageMaker Jumpstart Text2Text Generación de grandes modelos de lenguaje | Servicios web de Amazon

Hoy nos complace anunciar que ahora puede realizar transformaciones por lotes con JumpStart de Amazon SageMaker modelos de lenguaje grande (LLM) para Text2Text Generation. Las transformaciones por lotes son útiles en situaciones en las que las respuestas no necesitan ser en tiempo real y, por lo tanto, puede hacer inferencias por lotes para grandes conjuntos de datos de forma masiva. Para la transformación por lotes, se ejecuta un trabajo por lotes que toma la entrada por lotes como un conjunto de datos y un modelo previamente entrenado, y genera predicciones para cada punto de datos en el conjunto de datos. La transformación por lotes es rentable porque, a diferencia de los puntos finales alojados en tiempo real que tienen hardware persistente, los clústeres de transformación por lotes se eliminan cuando se completa el trabajo y, por lo tanto, el hardware solo se usa durante la duración del trabajo por lotes.

En algunos casos de uso, las solicitudes de inferencia en tiempo real se pueden agrupar en pequeños lotes para el procesamiento por lotes para crear respuestas en tiempo real o casi en tiempo real. Por ejemplo, si necesita procesar un flujo continuo de datos con baja latencia y alto rendimiento, invocar un extremo en tiempo real para cada solicitud por separado requeriría más recursos y podría llevar más tiempo procesar todas las solicitudes porque el procesamiento se realiza en serie. . Un mejor enfoque sería agrupar algunas de las solicitudes y llamar al punto final en tiempo real en modo de inferencia por lotes, que procesa sus solicitudes en un paso hacia adelante del modelo y devuelve la respuesta masiva para la solicitud en tiempo real o casi en tiempo real. . La latencia de la respuesta dependerá de la cantidad de solicitudes que agrupe y del tamaño de la memoria de la instancia; por lo tanto, puede ajustar el tamaño del lote según los requisitos de latencia y rendimiento de su empresa. Llamamos a esto inferencia por lotes en tiempo real porque combina el concepto de procesamiento por lotes sin dejar de proporcionar respuestas en tiempo real. Con la inferencia por lotes en tiempo real, puede lograr un equilibrio entre baja latencia y alto rendimiento, lo que le permite procesar grandes volúmenes de datos de manera oportuna y eficiente.

La transformación por lotes Jumpstart para los modelos Text2Text Generation le permite pasar los hiperparámetros por lotes a través de variables de entorno que aumentan aún más el rendimiento y minimizan la latencia.

JumpStart proporciona modelos de código abierto previamente entrenados para una amplia gama de tipos de problemas para ayudarlo a comenzar con el aprendizaje automático (ML). Puede entrenar y ajustar estos modelos de forma incremental antes de la implementación. JumpStart también proporciona plantillas de solución que configuran la infraestructura para casos de uso comunes y cuadernos de ejemplo ejecutables para ML con Amazon SageMaker. Puede acceder a los modelos previamente entrenados, las plantillas de solución y los ejemplos a través de la página de destino de JumpStart en Estudio Amazon SageMaker. También puede acceder a los modelos de JumpStart mediante el SDK de Python de SageMaker.

En esta publicación, demostramos cómo usar el estado del arte pre-entrenado Modelos text2text FLAN T5 de Hugging Face para transformación por lotes e inferencia por lotes en tiempo real.

Resumen de la solución

El cuaderno que muestra la transformación por lotes de modelos Text2Text FLAN T5 preentrenados de Abrazando la cara en disponible en el siguiente Repositorio GitHub. Este cuaderno utiliza datos de Hugging Face cnn_dailymail conjunto de datos para una tarea de resumen de texto utilizando SageMaker SDK.

Los siguientes son los pasos clave para implementar la transformación por lotes y la inferencia por lotes en tiempo real:

1. Configurar requisitos previos.
2. Seleccione un modelo previamente entrenado.
3. Recuperar artefactos para el modelo.
4. Especifique los hiperparámetros del trabajo de transformación por lotes.
5. Prepare los datos para la transformación por lotes.
6. Ejecute el trabajo de transformación por lotes.
7. Evaluar el resumen usando un ROUGE (Suplente orientado a la recuperación para la evaluación de Gisting).
8. Realice inferencias por lotes en tiempo real.

Configurar requisitos previos

Antes de ejecutar el portátil, debe completar algunos pasos de configuración inicial. Configuremos el rol de ejecución de SageMaker para que tenga permisos para ejecutar los servicios de AWS en su nombre:

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

Seleccione un modelo pre-entrenado

Usamos el modelo huggingface-text2text-flan-t5-large como modelo predeterminado. Opcionalmente, puede recuperar la lista de modelos Text2Text disponibles en JumpStart y elegir su modelo preferido. Este método proporciona una forma sencilla de seleccionar diferentes ID de modelo utilizando el mismo portátil. Para fines de demostración, usamos el modelo huggingface-text2text-flan-t5-large:

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

Recuperar artefactos para el modelo

Con SageMaker, podemos realizar inferencias en el modelo previamente entrenado, incluso sin ajustarlo primero en un nuevo conjunto de datos. Empezamos recuperando el deploy_image_uri, deploy_source_uriy model_uri para el modelo pre-entrenado:

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 trabajos de transformación por lotes

Puede pasar cualquier subconjunto de hiperparámetros como variables de entorno al trabajo de transformación por lotes. También puede pasar estos hiperparámetros en una carga JSON. Sin embargo, si está configurando variables de entorno para hiperparámetros como muestra el siguiente código, entonces no se usarán los hiperparámetros avanzados de los ejemplos individuales en la carga de líneas JSON. Si desea utilizar hiperparámetros de la carga útil, es posible que desee configurar el hyper_params_dict parámetro como nulo en su lugar.

#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 datos para la transformación por lotes

Ahora estamos listos para cargar el cnn_dailymail conjunto de datos de Hugging Face:

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

Revisamos cada entrada de datos y creamos los datos de entrada en el formato requerido. Creamos un articles.jsonl como un archivo de datos de prueba que contiene artículos que deben resumirse como carga útil de entrada. A medida que creamos este archivo, agregamos el mensaje "Briefly summarize this text:" a cada fila de entrada de prueba. Si desea tener diferentes hiperparámetros para cada entrada de prueba, puede agregar esos hiperparámetros como parte de la creación del conjunto de datos.

Nosotros creamos highlights.jsonl como el archivo de datos reales que contiene los aspectos más destacados de cada artículo almacenado en el archivo de prueba articles.jsonl. Almacenamos ambos archivos de prueba en un Servicio de almacenamiento simple de Amazon (Amazon S3) cubeta. Ver el siguiente 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"))

Ejecute el trabajo de transformación por lotes

Cuando inicia un trabajo de transformación por lotes, SageMaker inicia los recursos informáticos necesarios para procesar los datos, incluidas las instancias de CPU o GPU según el tipo de instancia seleccionado. Durante el trabajo de transformación por lotes, SageMaker aprovisiona y administra automáticamente los recursos informáticos necesarios para procesar los datos, incluidas las instancias, el almacenamiento y los recursos de red. Cuando se completa el trabajo de transformación por lotes, SageMaker limpia automáticamente los recursos informáticos. Esto significa que las instancias y el almacenamiento utilizados durante el trabajo se detienen y eliminan, lo que libera recursos y minimiza los costos. Ver el siguiente 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()

El siguiente es un registro de ejemplo de la articles.jsonl archivo de prueba Tenga en cuenta que el registro en este archivo tiene una identificación que coincidió con predict.jsonl registros de archivos que muestran un registro resumido como salida del modelo Hugging Face Text2Text. De manera similar, el archivo de datos reales también tiene una identificación coincidente para el registro de datos. La identificación coincidente en el archivo de prueba, el archivo de datos reales y el archivo de salida permite vincular los registros de entrada con los registros de salida para facilitar la interpretación de los resultados.

El siguiente es el registro de entrada de ejemplo proporcionado para el resumen:

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

El siguiente es el resultado previsto con resumen:

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

El siguiente es el resumen de la realidad básica para fines de evaluación del 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 ."}

A continuación, usamos la realidad del terreno y los resultados previstos para la evaluación del modelo.

Evaluar el modelo utilizando una puntuación ROUGE¶

ROUGE, o Recall-Oriented Understudy for Gisting Evaluation, es un conjunto de métricas y un paquete de software que se utiliza para evaluar el resumen automático y la traducción automática en el procesamiento del lenguaje natural. Las métricas comparan un resumen o traducción producidos automáticamente con un resumen o traducción de referencia (producido por humanos) o un conjunto de referencias.

En el siguiente código, combinamos los resúmenes predicho y original uniéndolos en la clave común id y use esto para calcular la puntuación de 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}

Realizar inferencia por lotes en tiempo real

A continuación, le mostramos cómo ejecutar la inferencia por lotes en tiempo real en el punto final al proporcionar las entradas como una lista. Usamos el mismo ID de modelo y conjunto de datos que antes, excepto que tomamos algunos registros del conjunto de datos de prueba y los usamos para invocar un punto final en tiempo real.

El siguiente código muestra cómo crear e implementar un punto final en tiempo real para la inferencia por lotes en tiempo 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
)

A continuación, preparamos nuestra carga útil de entrada. Para esto, usamos los datos que preparamos anteriormente y extraemos las primeras 10 entradas de prueba y agregamos las entradas de texto con los hiperparámetros que queremos usar. Proporcionamos esta carga útil al tiempo real invoke_endpoint. A continuación, la carga útil de la respuesta se devuelve como una lista de respuestas. Ver el siguiente 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')

Limpiar

Una vez que haya probado el punto final, asegúrese de eliminar el punto final de inferencia de SageMaker y elimine el modelo para evitar incurrir en cargos.

Conclusión

En este cuaderno, realizamos una transformación por lotes para mostrar el modelo Hugging Face Text2Text Generator para tareas de resumen. La transformación por lotes es ventajosa para obtener inferencias de grandes conjuntos de datos sin requerir un punto final persistente. Vinculamos los registros de entrada con las inferencias para ayudar en la interpretación de los resultados. Utilizamos la puntuación ROUGE para comparar el resumen de datos de prueba con el resumen generado por el modelo.

Además, demostramos la inferencia por lotes en tiempo real, donde puede enviar un pequeño lote de datos a un punto final en tiempo real para lograr un equilibrio entre la latencia y el rendimiento para escenarios como la transmisión de datos de entrada. La inferencia por lotes en tiempo real ayuda a aumentar el rendimiento de las solicitudes en tiempo real.

¡Pruebe la transformación por lotes con los modelos Text2Text Generation en SageMaker hoy y háganos saber sus comentarios!

Sobre los autores

Hemant Singh es un ingeniero de aprendizaje automático con experiencia en los algoritmos integrados de Amazon SageMaker JumpStart y Amazon SageMaker. Obtuvo su maestría del Instituto Courant de Ciencias Matemáticas y B.Tech de IIT Delhi. Tiene experiencia trabajando en una amplia gama de problemas de aprendizaje automático dentro del dominio del procesamiento del lenguaje natural, la visión artificial y el análisis de series temporales.

Rachna chadha es Principal Solutions Architect AI/ML en Cuentas Estratégicas en AWS. Rachna es una optimista que cree que el uso ético y responsable de la IA puede mejorar la sociedad en el futuro y generar prosperidad económica y social. En su tiempo libre, a Rachna le gusta pasar tiempo con su familia, hacer caminatas y escuchar música.

Dr. Ashish Khetan es científico senior aplicado con algoritmos integrados de Amazon SageMaker y ayuda a desarrollar algoritmos de aprendizaje automático. Obtuvo su doctorado en la Universidad de Illinois Urbana-Champaign. Es un investigador activo en aprendizaje automático e inferencia estadística, y ha publicado muchos artículos en conferencias NeurIPS, ICML, ICLR, JMLR, ACL y EMNLP.

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• PlatoAiStream. Inteligencia de datos Web3. Conocimiento amplificado. Accede Aquí.
• Acuñando el futuro con Adryenn Ashley. Accede Aquí.
• Compra y Vende Acciones en Empresas PRE-IPO con PREIPO®. Accede Aquí.
• Fuente: https://aws.amazon.com/blogs/machine-learning/perform-batch-transforms-with-amazon-sagemaker-jumpstart-text2text-generation-large-language-models/