Identifique información clave de documentos de texto mediante ajustes y HPO con Amazon SageMaker JumpStart

Las organizaciones de todos los sectores, como el comercio minorista, la banca, las finanzas, la atención médica, la fabricación y los préstamos, a menudo tienen que lidiar con grandes cantidades de documentos de texto no estructurados provenientes de diversas fuentes, como noticias, blogs, reseñas de productos, canales de atención al cliente y redes sociales. Estos documentos contienen información crítica que es clave para tomar decisiones comerciales importantes. A medida que crece una organización, se convierte en un desafío extraer información crítica de estos documentos. Con el avance del procesamiento del lenguaje natural (NLP) y las técnicas de aprendizaje automático (ML), podemos descubrir información valiosa y conexiones de estos documentos de texto rápidamente y con gran precisión, lo que ayuda a las empresas a tomar decisiones comerciales de calidad a tiempo. Los servicios de PNL completamente administrados también han acelerado la adopción de la PNL. Amazon Comprehend es un servicio completamente administrado que le permite crear modelos NLP personalizados que son específicos para sus requisitos, sin necesidad de tener experiencia en ML.

En esta publicación, demostramos cómo utilizar técnicas de ML de última generación para resolver cinco tareas diferentes de NLP: resumen de documentos, clasificación de texto, respuesta a preguntas, reconocimiento de entidades nombradas y extracción de relaciones. Para cada una de estas tareas de PNL, demostramos cómo usar Amazon SageMaker para realizar las siguientes acciones:

• Implemente y ejecute la inferencia en un modelo previamente entrenado
• Ajuste el modelo preentrenado en un nuevo conjunto de datos personalizado
• Mejore aún más el rendimiento de ajuste fino con Ajuste automático del modelo SageMaker
• Evalúe el rendimiento del modelo en los datos de prueba de reserva con varias métricas de evaluación

Aunque cubrimos cinco tareas específicas de NLP en esta publicación, puede usar esta solución como plantilla para generalizar el ajuste fino de modelos previamente entrenados con su propio conjunto de datos y, posteriormente, ejecutar la optimización de hiperparámetros para mejorar la precisión.

Plantillas de solución JumpStart

JumpStart de Amazon SageMaker proporciona soluciones integrales con un solo clic para muchos casos de uso comunes de ML. Explore los siguientes casos de uso para obtener más información sobre las plantillas de solución disponibles:

Las plantillas de solución JumpStart cubren una variedad de casos de uso, en cada uno de los cuales se ofrecen varias plantillas de solución diferentes (esta solución de Comprensión de documentos se encuentra en el caso de uso "Extraer y analizar datos de documentos").

Elija la plantilla de solución que mejor se adapte a su caso de uso desde la página de destino de JumpStart. Para obtener más información sobre soluciones específicas en cada caso de uso y cómo iniciar una solución JumpStart, consulte Plantillas de solución.

Resumen de la solución

La siguiente imagen muestra cómo puede usar esta solución con los componentes de SageMaker. Los trabajos de entrenamiento de SageMaker se usan para entrenar los distintos modelos de NLP, y los extremos de SageMaker se usan para implementar los modelos en cada etapa. Usamos Servicio de almacenamiento simple de Amazon (Amazon S3) junto con SageMaker para almacenar los datos de entrenamiento y los artefactos del modelo, y Reloj en la nube de Amazon para registrar el entrenamiento y las salidas de punto final.

Abra la solución Comprensión de documentos

Navegue a la solución Comprensión de documentos en JumpStart.

Ahora podemos echar un vistazo más de cerca a algunos de los activos que se incluyen en esta solución, comenzando con el cuaderno de demostración.

Cuaderno de demostración

Puede usar el cuaderno de demostración para enviar datos de ejemplo a puntos finales de modelos ya implementados para las tareas de resumen de documentos y respuesta a preguntas. El cuaderno de demostración le permite adquirir experiencia práctica consultando los datos de ejemplo.

Después de iniciar la solución Document Understanding, abra el cuaderno de demostración eligiendo Usar Endpoint en Notebook.

Profundicemos en cada uno de los cinco cuadernos principales de esta solución.

Requisitos previos

In Estudio Amazon SageMaker, asegúrese de estar usando el PyTorch 1.10 Python 3.8 CPU Optimized image/kernel para abrir los cuadernos. El entrenamiento usa cinco instancias ml.g4dn.2xlarge, por lo que debe generar una solicitud de aumento de límite de servicio si su cuenta requiere mayores límites para este tipo.

Clasificación de texto

La clasificación de texto se refiere a clasificar una oración de entrada en una de las etiquetas de clase del conjunto de datos de entrenamiento. Este cuaderno demuestra cómo usar el API JumpStart para la clasificación de textos.

Implementar y ejecutar la inferencia en el modelo previamente entrenado

El modelo de clasificación de texto que hemos elegido utilizar se basa en una incrustación de texto (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) modelo de Centro TensorFlow, que está previamente entrenado en conjuntos de datos de Wikipedia y BookCorpus.

El modelo disponible para la implementación se crea adjuntando una capa de clasificación binaria a la salida del modelo de incrustación de texto y luego ajustando todo el modelo en el SST-2 conjunto de datos, que se compone de críticas positivas y negativas de películas.

Para ejecutar la inferencia en este modelo, primero debemos descargar el contenedor de inferencia (deploy_image_uri), script de inferencia (deploy_source_uri), y modelo pre-entrenado (base_model_uri). Luego los pasamos como parámetros para instanciar un objeto modelo de SageMaker, que luego podemos implementar:

model = Model(
    image_uri=deploy_image_uri,
    source_dir=deploy_source_uri,
    model_data=base_model_uri,
    entry_point="inference.py",
    role=aws_role,
    predictor_cls=Predictor,
    name=endpoint_name_tc,
)
# deploy the Model.
base_model_predictor = model.deploy(
    initial_instance_count=1,
    instance_type=inference_instance_type,
    endpoint_name=endpoint_name_tc,
)

text1 = "astonishing ... ( frames ) profound ethical and philosophical questions in the form of dazzling pop entertainment" 
text2 = "simply stupid , irrelevant and deeply , truly , bottomlessly cynical "

El siguiente código muestra nuestras respuestas:

Inference:
Input text: 'astonishing ... ( frames ) profound ethical and philosophical questions in the form of dazzling pop entertainment'
Model prediction: [0.000452966779, 0.999547064]
Labels: [0, 1]
Predicted Label: 1 # value 0 means negative sentiment and value 1 means positive sentiment

Inference:
Input text: 'simply stupid , irrelevant and deeply , truly , bottomlessly cynical '
Model prediction: [0.998723, 0.00127695734]
Labels: [0, 1]
Predicted Label: 0

Ajuste el modelo preentrenado en un conjunto de datos personalizado

Acabamos de recorrer la ejecución de la inferencia en un modelo BERT previamente entrenado, que se ajustó en el SST-2 conjunto de datos

A continuación, analizamos cómo ajustar un modelo en un conjunto de datos personalizado con cualquier número de clases. El conjunto de datos que usamos para el ajuste fino sigue siendo el SST-2 conjunto de datos Puede reemplazar este conjunto de datos con cualquier conjunto de datos que le interese.

Recuperamos el contenedor Docker de entrenamiento, la fuente del algoritmo de entrenamiento y el modelo preentrenado:

from sagemaker import image_uris, model_uris, script_uris, hyperparameters

model_id, model_version = model_id, "*" # all the other options of model_id are the same as the one in Section 2.
training_instance_type = config.TRAINING_INSTANCE_TYPE

# Retrieve the docker image
train_image_uri = image_uris.retrieve(
    region=None,
    framework=None,
    model_id=model_id,
    model_version=model_version,
    image_scope="training",
    instance_type=training_instance_type,
)
# Retrieve the training script
train_source_uri = script_uris.retrieve(
    model_id=model_id, model_version=model_version, script_scope="training"
)
# Retrieve the pre-trained model tarball to further fine-tune
train_model_uri = model_uris.retrieve(
    model_id=model_id, model_version=model_version, model_scope="training"
)

Para los hiperparámetros específicos del algoritmo, comenzamos por obtener un diccionario de Python de los hiperparámetros de entrenamiento que acepta el algoritmo con sus valores predeterminados. Puede anularlos con valores personalizados, como se muestra en el siguiente código:

from sagemaker import hyperparameters

# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)

# [Optional] Override default hyperparameters with custom values
hyperparameters["batch-size"] = "64"
hyperparameters["adam-learning-rate"] = "1e-6"

El conjunto de datos (SST-2) se divide en conjuntos de entrenamiento, validación y prueba, donde el conjunto de entrenamiento se usa para ajustar el modelo, el conjunto de validación se usa para calcular las métricas de evaluación que se pueden usar para HPO y el conjunto de prueba se usa como datos reservados para evaluar el rendimiento del modelo. A continuación, el conjunto de datos de capacitación y validación se carga en Amazon S3 y se usa para iniciar el trabajo de capacitación de ajuste:

# Create SageMaker Estimator instance
tc_estimator = Estimator(
    role=role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
    output_path=s3_output_location,
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
    base_job_name=training_job_name,
)

training_data_path_updated = f"s3://{config.S3_BUCKET}/{prefix}/train"
# Launch a SageMaker Training job by passing s3 path of the training data
tc_estimator.fit({"training": training_data_path_updated}, logs=True)

Una vez que se completa el trabajo de ajuste, implementamos el modelo, ejecutamos la inferencia en el conjunto de datos de prueba de reserva y calculamos las métricas de evaluación. Debido a que es una tarea de clasificación binaria, usamos el puntuación de precisión y Puntuación F1 como las métricas de evaluación. Un valor mayor indica un mejor rendimiento. La siguiente captura de pantalla muestra nuestros resultados.

Mejore aún más el rendimiento del ajuste fino con el ajuste automático de modelos de SageMaker

En este paso, demostramos cómo puede mejorar aún más el rendimiento del modelo ajustando el modelo con el ajuste automático de modelos de SageMaker. El ajuste automático del modelo, también conocido como optimización de hiperparámetros (HPO), encuentra la mejor versión de un modelo mediante la ejecución de varios trabajos de entrenamiento en su conjunto de datos con un rango de hiperparámetros que usted especifique. Luego, elige los valores de hiperparámetros que dan como resultado un modelo que funciona mejor, según lo medido por una métrica que elija, en el conjunto de datos de validación.

Primero, establecemos el objetivo como el puntaje de precisión en los datos de validación (val_accuracy) y métricas definidas para el trabajo de ajuste especificando el nombre de la métrica objetivo y una expresión regular (regex). La expresión regular se usa para hacer coincidir la salida del registro del algoritmo y capturar los valores numéricos de las métricas. A continuación, especificamos rangos de hiperparámetros para seleccionar los mejores valores de hiperparámetros. Establecemos el número total de trabajos de ajuste en seis y distribuimos estos trabajos en tres diferentes Nube informática elástica de Amazon (Amazon EC2) instancias para ejecutar trabajos de ajuste paralelos. Ver el siguiente código:

# Define objective metric per framework, based on which the best model will be selected.
metric_definitions_per_model = {
    "tensorflow": {
        "metrics": [{"Name": "val_accuracy", "Regex": "val_accuracy: ([0-9.]+)"}],
        "type": "Maximize",
    }
}

# You can select from the hyperparameters supported by the model, and configure ranges of values to be searched for training the optimal model.(https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-define-ranges.html)
hyperparameter_ranges = {
    "adam-learning-rate": ContinuousParameter(0.00001, 0.01, scaling_type="Logarithmic")
}

# Increase the total number of training jobs run by AMT, for increased accuracy (and training time).
max_jobs = 6
# Change parallel training jobs run by AMT to reduce total training time, constrained by your account limits.
# if max_jobs=max_parallel_jobs then Bayesian search turns to Random.
max_parallel_jobs = 3

Pasamos esos valores para instanciar un objeto de SageMaker Estimator, similar a lo que hicimos en el paso de ajuste fino anterior. En lugar de llamar al fit función de la Estimator objeto, pasamos el Estimator objeto como un parámetro para el Sintonizador de hiperparámetros constructor y llamar al fit función de la misma para iniciar trabajos de ajuste:

hp_tuner = HyperparameterTuner(
    tc_estimator,
    metric_definitions["metrics"][0]["Name"],
    hyperparameter_ranges,
    metric_definitions["metrics"],
    max_jobs=max_jobs,
    max_parallel_jobs=max_parallel_jobs,
    objective_type=metric_definitions["type"],
    base_tuning_job_name=tuning_job_name,
)

# Launch a SageMaker Tuning job to search for the best hyperparameters
hp_tuner.fit({"training": training_data_path_updated})

Una vez que se completan los trabajos de ajuste, implementamos el modelo que brinda la mejor puntuación de métrica de evaluación en el conjunto de datos de validación, realizamos inferencias en el mismo conjunto de datos de prueba de retención que hicimos en la sección anterior y calculamos las métricas de evaluación.

Los resultados muestran que el modelo seleccionado por el ajuste automático del modelo supera significativamente al modelo ajustado en la sección anterior en un conjunto de datos de prueba de retención.

Reconocimiento de entidad nombrada

El reconocimiento de entidades nombradas (NER) es el proceso de detección y clasificación de entidades nombradas en categorías predefinidas, como nombres de personas, organizaciones, ubicaciones y cantidades. Hay muchos casos de uso del mundo real para NER, como motores de recomendación, categorización y asignación de tickets de atención al cliente al departamento correcto, extracción de información esencial de informes de pacientes en atención médica y clasificación de contenido de noticias y blogs.

Implementar y ejecutar la inferencia en el modelo previamente entrenado

Desplegamos el Es_core_web_md modelo de la spacy biblioteca. spaCy es una biblioteca NLP de código abierto que se puede usar para varias tareas y tiene métodos integrados para NER. Usamos un contenedor de aprendizaje profundo (DLC) de AWS PyTorch con un modo de secuencia de comandos e instalamos la biblioteca spaCy como una dependencia en la parte superior del contenedor.

A continuación, un punto de entrada para el script (argumento entry_point.py), que contiene todo el código para descargar y cargar el En_core_web_md modelar y realizar inferencias sobre los datos que se envían al punto final. Finalmente, todavía tenemos que proporcionar model_data como el modelo pre-entrenado para la inferencia. Porque el pre-entrenado En_core_web_md el modelo se descarga sobre la marcha, que se especifica en el script de entrada, proporcionamos un archivo de almacenamiento vacío. Después de implementar el punto final, puede invocar el punto final directamente desde el cuaderno utilizando el SDK de Python de SageMaker Predictor. Ver el siguiente código:

model = PyTorchModel(
    model_data=f"{config.SOURCE_S3_PATH}/artifacts/models/empty.tar.gz",
    entry_point="entry_point.py",
    source_dir="../containers/entity_recognition",
    role=config.IAM_ROLE,
    framework_version="1.5.0",
    py_version="py3",
    code_location="s3://" + config.S3_BUCKET + "/code",
    env={
        "MMS_DEFAULT_RESPONSE_TIMEOUT": "3000"
    }
)
predictor = model.deploy(
    endpoint_name=endpoint_name,
    instance_type=config.HOSTING_INSTANCE_TYPE,
    initial_instance_count=1,
    serializer=JSONSerializer(),
    deserializer=JSONDeserializer()
)

Los datos de entrada para el modelo son un documento de texto. El modelo de entidad nombrada extrae fragmentos de sustantivos y entidades nombradas en el documento de texto y las clasifica en varios tipos diferentes (como personas, lugares y organizaciones). La entrada y salida de ejemplo se muestran en el siguiente código. los start_char El parámetro indica el desplazamiento de caracteres para el inicio del lapso, y end_char indica el final del tramo.

data = {'text': 'Amazon SageMaker is a fully managed service that provides every developer and data scientist with the ability to build, train, and deploy machine learning (ML) models quickly.'}
response = predictor.predict(data=data)

print(response['entities'])
print(response['noun_chunks'])

[{'text': 'Amazon SageMaker', 'start_char': 0, 'end_char': 16, 'label': 'ORG'}]
[{'text': 'Amazon SageMaker', 'start_char': 0, 'end_char': 16}, {'text': 'a fully managed service', 'start_char': 20, 'end_char': 43}, {'text': 'that', 'start_char': 44, 'end_char': 48}, {'text': 'every developer and data scientist', 'start_char': 58, 'end_char': 92}, {'text': 'the ability', 'start_char': 98, 'end_char': 109}, {'text': 'ML', 'start_char': 156, 'end_char': 158}]

Ajuste el modelo preentrenado en un conjunto de datos personalizado

En este paso, demostramos cómo ajustar modelos de lenguaje previamente entrenados para NER en su propio conjunto de datos. El paso de ajuste fino actualiza los parámetros del modelo para capturar la característica de sus propios datos y mejorar la precisión. usamos el WikiANN conjunto de datos (PAN-X) para afinar la DistilBERT-base-sin carcasa Modelo de transformador de Hugging Face.

El conjunto de datos se divide en conjuntos de entrenamiento, validación y prueba.

A continuación, especificamos los hiperparámetros del modelo y usamos un DLC de AWS Hugging Face con un modo de secuencia de comandos (argumento entry_point) para activar el trabajo de ajuste fino:

hyperparameters = {
    "pretrained-model": "distilbert-base-uncased",
    "learning-rate": 2e-6,
    "num-train-epochs": 2,
    "batch-size": 16,
    "weight-decay": 1e-5,
    "early-stopping-patience": 2,
}

ner_estimator = HuggingFace(
    pytorch_version='1.10.2',
    py_version='py38',
    transformers_version="4.17.0",
    entry_point='training.py',
    source_dir='../containers/entity_recognition/finetuning',
    hyperparameters=hyperparameters,
    role=aws_role,
    instance_count=1,
    instance_type=training_instance_type,
    output_path=f"s3://{bucket}/{prefix}/output",
    code_location=f"s3://{bucket}/{prefix}/output",
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
    sagemaker_session=sess,
    volume_size=30,
    env={
        'MMS_DEFAULT_RESPONSE_TIMEOUT': '500'
    },
    base_job_name = training_job_name
)

Una vez que se completa el trabajo de ajuste, implementamos un punto final y consultamos ese punto final con los datos de prueba reservados. Para consultar el punto final, cada cadena de texto debe tokenizarse en uno o varios tokens y enviarse al modelo de transformador. Cada token obtiene una etiqueta de entidad nombrada predicha. Debido a que cada cadena de texto se puede convertir en tokens en uno o varios tokens, necesitamos duplicar la etiqueta de entidad con nombre de verdad básica de la cadena para todos los tokens que están asociados a ella. El cuaderno provisto lo guía a través de los pasos para lograr esto.

Por último, utilizamos métricas de evaluación incorporadas Hugging Face secuencial para calcular los puntajes de evaluación en los datos de prueba de reserva. Las métricas de evaluación utilizadas son precisión general, recuperación general, F1 general y precisión. La siguiente captura de pantalla muestra nuestros resultados.

Mejore aún más el rendimiento del ajuste fino con el ajuste automático de modelos de SageMaker

De manera similar a la clasificación de texto, demostramos cómo puede mejorar aún más el rendimiento del modelo ajustando el modelo con el ajuste automático de modelos de SageMaker. Para ejecutar el trabajo de ajuste, necesitamos definir una métrica objetiva que queremos usar para evaluar el rendimiento del modelo en el conjunto de datos de validación (puntuación F1 en este caso), rangos de hiperparámetros para seleccionar los mejores valores de hiperparámetro, así como configuraciones de trabajo de ajuste como número máximo de trabajos de ajuste y número de trabajos paralelos para iniciar a la vez:

hyperparameters_range = {
    "learning-rate": ContinuousParameter(1e-5, 0.1, scaling_type="Logarithmic"),
    "weight-decay": ContinuousParameter(1e-6, 1e-2, scaling_type="Logarithmic"),
}

tuner = HyperparameterTuner(
    estimator,
    "f1",
    hyperparameters_range,
    [{"Name": "f1", "Regex": "'eval_f1': ([0-9.]+)"}],
    max_jobs=6,
    max_parallel_jobs=3,
    objective_type="Maximize",
    base_tuning_job_name=tuning_job_name,
)

tuner.fit({
    "train": f"s3://{bucket}/{prefix}/train/",
    "validation": f"s3://{bucket}/{prefix}/validation/",
}, logs=True)

Una vez que se completan los trabajos de ajuste, implementamos el modelo que brinda la mejor puntuación de métrica de evaluación en el conjunto de datos de validación, realizamos inferencias en el mismo conjunto de datos de prueba de retención que hicimos en la sección anterior y calculamos las métricas de evaluación.

Podemos ver que el modelo con HPO logra un rendimiento significativamente mejor en todas las métricas.

Respuesta a la pregunta

La respuesta a preguntas es útil cuando desea consultar una gran cantidad de texto para obtener información específica. Permite a un usuario expresar una pregunta en lenguaje natural y obtener una respuesta inmediata y breve. Los sistemas de respuesta a preguntas impulsados ​​por NLP se pueden usar en motores de búsqueda e interfaces de conversación telefónica.

Implementar y ejecutar la inferencia en el modelo previamente entrenado

Nuestro modelo pre-entrenado es el modelo extractivo de respuesta a preguntas (EQA) bert-large-escuadrón-ajustado-de-palabra-completa-sin-casar construido sobre un modelo Transformer de Hugging Face. Usamos un DLC de AWS PyTorch con un modo de secuencia de comandos e instalamos el transformers biblioteca como una dependencia en la parte superior del contenedor. Similar a la tarea NER, proporcionamos un archivo vacío en el argumento model_data porque el modelo preentrenado se descarga sobre la marcha. Después de implementar el punto final, puede invocar el punto final directamente desde el cuaderno utilizando el SDK de Python de SageMaker Predictor. Ver el siguiente código:

model = PyTorchModel(
    model_data=f"{config.SOURCE_S3_PATH}/artifacts/models/empty.tar.gz",
    entry_point="entry_point.py",
    source_dir="../containers/question_answering",
    role=config.IAM_ROLE,
    framework_version="1.5.0",
    py_version="py3",
    code_location="s3://" + config.S3_BUCKET + "/code",
    env={
        "MODEL_ASSETS_S3_BUCKET": config.SOURCE_S3_BUCKET,
        "MODEL_ASSETS_S3_PREFIX": f"{config.SOURCE_S3_PREFIX}/artifacts/models/question_answering/",
        "MMS_DEFAULT_RESPONSE_TIMEOUT": "3000",
    },
)

Todo lo que necesitamos hacer es construir un objeto de diccionario con dos claves. context es el texto del que deseamos recuperar información. question es la consulta en lenguaje natural que especifica qué información nos interesa extraer. Nosotros llamamos predict en nuestro predictor, y deberíamos obtener una respuesta del punto final que contenga las respuestas más probables:

data = {'question': 'what is my name?', 'context': "my name is thom"}
response = predictor.predict(data=data)

Tenemos la respuesta y podemos imprimir las respuestas más probables que se han extraído del texto anterior. Cada respuesta tiene una puntuación de confianza que se usa para la clasificación (pero esta puntuación no debe interpretarse como una probabilidad real). Además de la respuesta textual, también obtiene los índices de caracteres de inicio y final de la respuesta del contexto original:

print(response['answers'])
[{'score': 0.9793591499328613, 'start': 11, 'end': 15, 'answer': 'thom'}, 
{'score': 0.02019440196454525, 'start': 0, 'end': 15, 'answer': 'my name is thom'}, 
{'score': 4.349117443780415e-05, 'start': 3, 'end': 15, 'answer': 'name is thom'}]

Ahora ajustamos este modelo con nuestro propio conjunto de datos personalizado para obtener mejores resultados.

Ajuste el modelo preentrenado en un conjunto de datos personalizado

En este paso, demostramos cómo ajustar modelos de lenguaje previamente entrenados para EQA en su propio conjunto de datos. El paso de ajuste fino actualiza los parámetros del modelo para capturar la característica de sus propios datos y mejorar la precisión. usamos el Squad2.0 conjunto de datos para ajustar un modelo de incrustación de texto Bert-base-sin carcasa de Cara abrazada. El modelo disponible para el ajuste fino adjunta una capa de extracción de respuestas al modelo de incrustación de texto e inicializa los parámetros de la capa en valores aleatorios. El paso de ajuste fino ajusta todos los parámetros del modelo para minimizar el error de predicción en los datos de entrada y devuelve el modelo ajustado.

Similar a la tarea de clasificación de texto, el conjunto de datos (SQuAD2.0) se divide en conjunto de entrenamiento, validación y prueba.

A continuación, especificamos los hiperparámetros del modelo y usamos el API JumpStart para activar un trabajo de ajuste fino:

hyperparameters = {'epochs': '3', 'adam-learning-rate': '2e-05', 'batch-size': '16'}

eqa_estimator = Estimator(
    role=role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
    output_path=s3_output_location,
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
    base_job_name=training_job_name,
    debugger_hook_config=False,
)

training_data_path_updated = f"s3://{config.S3_BUCKET}/{prefix}/train"
# Launch a SageMaker Training job by passing s3 path of the training data
eqa_estimator.fit({"training": training_data_path_updated}, logs=True)

Una vez que se completa el trabajo de ajuste, implementamos el modelo, ejecutamos la inferencia en el conjunto de datos de prueba de reserva y calculamos las métricas de evaluación. Las métricas de evaluación utilizadas son la puntuación media de coincidencia exacta y la puntuación F1 media. La siguiente captura de pantalla muestra los resultados.

Mejore aún más el rendimiento del ajuste fino con el ajuste automático de modelos de SageMaker

Al igual que en las secciones anteriores, utilizamos un HyperparameterTuner objeto para iniciar trabajos de ajuste:

hyperparameter_ranges = {
    "adam-learning-rate": ContinuousParameter(0.00001, 0.01, scaling_type="Logarithmic"),
    "epochs": IntegerParameter(3, 10),
    "train-only-top-layer": CategoricalParameter(["True", "False"]),
}

hp_tuner = HyperparameterTuner(
    eqa_estimator,
    metric_definitions["metrics"][0]["Name"],
    hyperparameter_ranges,
    metric_definitions["metrics"],
    max_jobs=max_jobs,
    max_parallel_jobs=max_parallel_jobs,
    objective_type=metric_definitions["type"],
    base_tuning_job_name=training_job_name,
)

# Launch a SageMaker Tuning job to search for the best hyperparameters
hp_tuner.fit({"training": training_data_path_updated})

Una vez que se completan los trabajos de ajuste, implementamos el modelo que brinda la mejor puntuación de métrica de evaluación en el conjunto de datos de validación, realizamos inferencias en el mismo conjunto de datos de prueba de retención que hicimos en la sección anterior y calculamos las métricas de evaluación.

Podemos ver que el modelo con HPO muestra un rendimiento significativamente mejor en los datos de prueba de espera.

Extracción de relaciones

La extracción de relaciones es la tarea de extraer relaciones semánticas del texto, que generalmente ocurren entre dos o más entidades. La extracción de relaciones juega un papel importante en la extracción de información estructurada de fuentes no estructuradas, como el texto sin formato. En este cuaderno, demostramos dos casos de uso de extracción de relaciones.

Ajuste el modelo preentrenado en un conjunto de datos personalizado

Utilizamos un modelo de extracción de relaciones basado en un BERT-base-sin carcasa modelo utilizando transformadores de la Abrazar transformadores faciales biblioteca. El modelo para el ajuste fino adjunta una capa de clasificación lineal que toma un par de incrustaciones de tokens generadas por el modelo de incrustación de texto e inicializa los parámetros de la capa en valores aleatorios. El paso de ajuste fino ajusta todos los parámetros del modelo para minimizar el error de predicción en los datos de entrada y devuelve el modelo ajustado.

El conjunto de datos con el que afinamos el modelo es SemEval-2010 Tarea 8. El modelo devuelto por el ajuste fino se puede implementar aún más para la inferencia.

El conjunto de datos contiene conjuntos de entrenamiento, validación y prueba.

Usamos el DLC de AWS PyTorch con un modo de secuencia de comandos del SDK de Python de SageMaker, donde el transformers biblioteca se instala como la dependencia en la parte superior del contenedor. Definimos el SageMaker PyTorch estimador y un conjunto de hiperparámetros como el modelo previamente entrenado, la tasa de aprendizaje y los números de época para realizar el ajuste fino. El código para ajustar el modelo de extracción de relaciones se define en el entry_point.py. Ver el siguiente código:

hyperparameters = {
    "pretrained-model": "bert-base-uncased",
    "learning-rate": 0.0002,
    "max-epoch": 2,
    "weight-decay": 0,
    "batch-size": 16,
    "accumulate-grad-batches": 2,
    "gradient-clip-val": 1.0
}

re_estimator = PyTorch(
    framework_version='1.5.0',
    py_version='py3',
    entry_point='entry_point.py',
    source_dir='../containers/relationship_extraction',
    hyperparameters=hyperparameters,
    role=aws_role,
    instance_count=1,
    instance_type=train_instance_type,
    output_path=f"s3://{bucket}/{prefix}/output",
    code_location=f"s3://{bucket}/{prefix}/output",
    base_job_name=training_job_name,
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
    sagemaker_session=sess,
    volume_size=30,
    env={
        'MMS_DEFAULT_RESPONSE_TIMEOUT': '500'
    },
    debugger_hook_config=False
)

re_estimator.fit(
    {
        "train": f"s3://{bucket}/{prefix}/train/",
        "validation": f"s3://{bucket}/{prefix}/validation/",
    }
)

Mejore aún más el rendimiento del ajuste fino con el ajuste automático de modelos de SageMaker

Al igual que en las secciones anteriores, utilizamos un HyperparameterTuner objeto para interactuar con las API de ajuste de hiperparámetros de SageMaker. Podemos comenzar el trabajo de ajuste de hiperparámetros llamando al fit método:

hyperparameters = {
    "max-epoch": 2,
    "weight-decay": 0,
    "batch-size": 16,
    "accumulate-grad-batches": 2,
    "gradient-clip-val": 1.0
}

estimator = PyTorch(
    framework_version='1.5.0',
    py_version='py3',
    entry_point='entry_point.py',
    source_dir='../containers/relationship_extraction',
    hyperparameters=hyperparameters,
    role=aws_role,
    instance_count=1,
    instance_type=train_instance_type,
    output_path=f"s3://{bucket}/{prefix}/output",
    code_location=f"s3://{bucket}/{prefix}/output",
    base_job_name=tuning_job_name,
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
    sagemaker_session=sess,
    volume_size=30,
    env={
        'MMS_DEFAULT_RESPONSE_TIMEOUT': '500'
    },
    debugger_hook_config=False
    
    re_tuner = HyperparameterTuner(
    estimator,
    metric_definitions["metrics"][0]["Name"],
    hyperparameter_ranges,
    metric_definitions["metrics"],
    max_jobs=max_jobs,
    max_parallel_jobs=max_parallel_jobs,
    objective_type=metric_definitions["type"],
    base_tuning_job_name=tuning_job_name,
)

re_tuner.fit({
    "train": f"s3://{bucket}/{prefix}/train/",
    "validation": f"s3://{bucket}/{prefix}/validation/",
})

Cuando se completa el trabajo de ajuste de hiperparámetros, realizamos la inferencia y verificamos el puntaje de evaluación.

Podemos ver que el modelo con HPO muestra un mejor rendimiento en los datos de prueba de espera.

Resumen de documentos

El resumen de documentos o textos es la tarea de condensar grandes cantidades de datos de texto en un subconjunto más pequeño de oraciones significativas que representan la información más importante o relevante dentro del contenido original. El resumen de documentos es una técnica útil para extraer información importante de grandes cantidades de datos de texto en unas pocas oraciones. El resumen de texto se utiliza en muchos casos de uso, como el procesamiento de documentos y la extracción de información de blogs, artículos y noticias.

Este cuaderno demuestra cómo implementar el modelo de resumen de documentos base T5 del desplegable Abrazar transformadores faciales biblioteca. También probamos los puntos finales implementados usando un artículo de texto y evaluamos los resultados usando la métrica de evaluación incorporada Hugging Face ROUGE.

Al igual que en los cuadernos de respuesta a preguntas y NER, usamos el PyTorchModel del SDK de Python de SageMaker junto con un entry_point.py secuencia de comandos para cargar el modelo basado en T5 en un punto final HTTPS. Una vez que el punto final se implementa correctamente, podemos enviar un artículo de texto al punto final para obtener una respuesta de predicción:

ARTICLE = """ Documents are a primary tool for communication,
collaboration, record keeping, and transactions across industries,
including financial, medical, legal, and real estate. The format of data
can pose an extra challenge in data extraction, especially if the content
is typed, handwritten, or embedded in a form or table. Furthermore,
extracting data from your documents is manual, error-prone, time-consuming,
expensive, and does not scale. Amazon Textract is a machine learning (ML)
service that extracts printed text and other data from documents as well as
tables and forms. We’re pleased to announce two new features for Amazon
Textract: support for handwriting in English documents, and expanding
language support for extracting printed text from documents typed in
Spanish, Portuguese, French, German, and Italian. Many documents, such as
medical intake forms or employment applications, contain both handwritten
and printed text. The ability to extract text and handwriting has been a
need our customers have asked us for. Amazon Textract can now extract
printed text and handwriting from documents written in English with high
confidence scores, whether it’s free-form text or text embedded in tables
and forms. Documents can also contain a mix of typed text or handwritten
text. The following image shows an example input document containing a mix
of typed and handwritten text, and its converted output document.."""

data = {'text': ARTICLE}
response = predictor.predict(data=data)
print(response['summary'])

"""Amazon Textract is a machine learning (ML) service that extracts printed text 
and other data from documents as well as tables and forms . 
customers can now extract and process documents in more languages .
support for handwriting in english documents and expanding language support for extracting 
printed text ."""

A continuación, evaluamos y comparamos el artículo de texto y el resultado del resumen utilizando la métrica ROUGE. Se calculan tres métricas de evaluación: rougeN, rougeLy rougeLsum. rougeN mide el número de coincidencias n-grams entre el texto generado por el modelo (resultado de resumen) y un reference (texto de entrada). las métricas rougeL y rougeLsum mida las secuencias de palabras coincidentes más largas buscando las subcadenas comunes más largas en los resúmenes generados y de referencia. Para cada métrica, se calculan los intervalos de confianza para la precisión, la recuperación y la puntuación F1. Consulte el siguiente código:

results = rouge.compute(predictions=[response['summary']], references=[ARTICLE])

rouge1: AggregateScore(low=Score(precision=1.0, recall=0.1070615034168565, fmeasure=0.1934156378600823), 
mid=Score(precision=1.0, recall=0.1070615034168565, fmeasure=0.1934156378600823), high=Score(precision=1.0, recall=0.1070615034168565, fmeasure=0.1934156378600823))

rouge2: AggregateScore(low=Score(precision=0.9565217391304348, recall=0.1004566210045662, fmeasure=0.18181818181818182), 
mid=Score(precision=0.9565217391304348, recall=0.1004566210045662, fmeasure=0.18181818181818182), high=Score(precision=0.9565217391304348, recall=0.1004566210045662, 
fmeasure=0.18181818181818182))

rougeL: AggregateScore(low=Score(precision=0.8085106382978723, recall=0.08656036446469248, fmeasure=0.15637860082304528), 
mid=Score(precision=0.8085106382978723, recall=0.08656036446469248, fmeasure=0.15637860082304528), high=Score(precision=0.8085106382978723, recall=0.08656036446469248, 
fmeasure=0.15637860082304528))

rougeLsum: AggregateScore(low=Score(precision=0.9787234042553191, recall=0.10478359908883828, fmeasure=0.18930041152263374), 
mid=Score(precision=0.9787234042553191, recall=0.10478359908883828, fmeasure=0.18930041152263374), high=Score(precision=0.9787234042553191, recall=0.10478359908883828, 
fmeasure=0.18930041152263374))

Limpiar

Los recursos creados para esta solución se pueden eliminar mediante el Eliminar todos los recursos desde el IDE de SageMaker Studio. Cada cuaderno también proporciona una sección de limpieza con el código para eliminar los puntos finales.

Conclusión

En esta publicación, demostramos cómo utilizar técnicas de ML de última generación para resolver cinco tareas diferentes de NLP: resumen de documentos, clasificación de texto, preguntas y respuestas, reconocimiento de entidades nombradas y extracción de relaciones mediante Jumpstart. Comience con Jumpstart ahora!

Acerca de los autores

Dra. Xin Huang es un científico aplicado para los algoritmos integrados de Amazon SageMaker JumpStart y Amazon SageMaker. Se centra en el desarrollo de algoritmos escalables de aprendizaje automático. Sus intereses de investigación se encuentran en el área del procesamiento del lenguaje natural, el aprendizaje profundo explicable en datos tabulares y el análisis sólido de la agrupación de espacio-tiempo no paramétrica. Ha publicado muchos artículos en conferencias ACL, ICDM, KDD y la revista Royal Statistical Society: Serie A.

Vivek Gangasani es arquitecto sénior de soluciones de aprendizaje automático en Amazon Web Services. Ayuda a las empresas emergentes a crear y poner en funcionamiento aplicaciones de IA/ML. Actualmente se centra en combinar su experiencia en contenedores y aprendizaje automático para ofrecer soluciones en MLOps, ML Inference y low-code ML. En su tiempo libre, disfruta probando nuevos restaurantes y explorando tendencias emergentes en IA y aprendizaje profundo.

Geremy Cohen es arquitecto de soluciones en AWS, donde ayuda a los clientes a crear soluciones de vanguardia basadas en la nube. En su tiempo libre, disfruta de caminatas cortas en la playa, explora el área de la bahía con su familia, arregla cosas en la casa, rompe cosas en la casa y hace barbacoas.

neelam koshiya es un arquitecto de soluciones empresariales en AWS. Su enfoque actual es ayudar a los clientes empresariales con su viaje de adopción en la nube para obtener resultados comerciales estratégicos. En su tiempo libre, le gusta leer y estar al aire libre.