Identifiez les informations clés à partir de documents texte grâce à des ajustements et HPO avec Amazon SageMaker JumpStart

Les organisations de secteurs tels que la vente au détail, la banque, la finance, la santé, la fabrication et les prêts doivent souvent gérer de grandes quantités de documents texte non structurés provenant de diverses sources, telles que des actualités, des blogs, des critiques de produits, des canaux de support client et des médias sociaux. Ces documents contiennent des informations critiques qui sont essentielles pour prendre des décisions commerciales importantes. Au fur et à mesure qu'une organisation grandit, il devient difficile d'extraire des informations critiques de ces documents. Avec l'avancement des techniques de traitement du langage naturel (NLP) et d'apprentissage automatique (ML), nous pouvons découvrir rapidement et avec une grande précision des informations et des liens précieux à partir de ces documents textuels, aidant ainsi les entreprises à prendre des décisions commerciales de qualité dans les délais. Les services de PNL entièrement gérés ont également accéléré l'adoption de la PNL. Amazon comprendre est un service entièrement géré qui vous permet de créer des modèles NLP personnalisés spécifiques à vos besoins, sans avoir besoin d'une expertise en ML.

Dans cet article, nous montrons comment utiliser des techniques ML de pointe pour résoudre cinq tâches NLP différentes : résumé de documents, classification de texte, réponse aux questions, reconnaissance d'entités nommées et extraction de relations. Pour chacune de ces tâches PNL, nous montrons comment utiliser Amazon Sage Maker pour effectuer les actions suivantes :

• Déployer et exécuter l'inférence sur un modèle pré-entraîné
• Affiner le modèle pré-formé sur un nouvel ensemble de données personnalisé
• Améliorez encore les performances de réglage fin avec Réglage automatique du modèle SageMaker
• Évaluer les performances du modèle sur les données de test retenues avec diverses métriques d'évaluation

Bien que nous couvrons cinq tâches NLP spécifiques dans cet article, vous pouvez utiliser cette solution comme modèle pour généraliser le réglage fin des modèles pré-formés avec votre propre ensemble de données, puis exécuter l'optimisation des hyperparamètres pour améliorer la précision.

Modèles de solution JumpStart

Amazon SageMaker JumpStart fournit des solutions de bout en bout en un clic pour de nombreux cas d'utilisation courants du ML. Explorez les cas d'utilisation suivants pour plus d'informations sur les modèles de solution disponibles :

Les modèles de solution JumpStart couvrent une variété de cas d'utilisation, sous chacun desquels plusieurs modèles de solution différents sont proposés (cette solution Document Understanding est sous le cas d'utilisation "Extraire et analyser les données des documents").

Choisissez le modèle de solution qui correspond le mieux à votre cas d'utilisation sur la page d'accueil JumpStart. Pour plus d'informations sur les solutions spécifiques à chaque cas d'utilisation et sur la façon de lancer une solution JumpStart, voir Modèles de solutions.

Vue d'ensemble de la solution

L'image suivante montre comment vous pouvez utiliser cette solution avec les composants SageMaker. Les tâches de formation SageMaker sont utilisées pour former les différents modèles NLP, et les points de terminaison SageMaker sont utilisés pour déployer les modèles à chaque étape. Nous utilisons Service de stockage simple Amazon (Amazon S3) aux côtés de SageMaker pour stocker les données de formation et les artefacts de modèle, et Amazon Cloud Watch pour consigner les sorties de formation et de point de terminaison.

Ouvrir la solution Document Understanding

Accédez à la solution Document Understanding dans JumpStart.

Nous pouvons maintenant examiner de plus près certains des actifs inclus dans cette solution, à commencer par le bloc-notes de démonstration.

Carnet de démonstration

Vous pouvez utiliser le bloc-notes de démonstration pour envoyer des exemples de données aux points de terminaison de modèle déjà déployés pour les tâches de synthèse de document et de réponse aux questions. Le bloc-notes de démonstration vous permet d'acquérir rapidement une expérience pratique en interrogeant les exemples de données.

Après avoir lancé la solution Document Understanding, ouvrez le bloc-notes de démonstration en choisissant Utiliser le point de terminaison dans Notebook.

Plongeons plus profondément dans chacun des cinq ordinateurs portables principaux de cette solution.

Pré-requis

In Amazon SageMakerStudio, assurez-vous d'utiliser le PyTorch 1.10 Python 3.8 CPU Optimized image/kernel pour ouvrir les cahiers. La formation utilise cinq instances ml.g4dn.2xlarge, vous devez donc augmenter un demande d'augmentation de limite de service si votre compte nécessite des limites plus élevées pour ce type.

Classification de texte

La classification de texte fait référence à la classification d'une phrase d'entrée dans l'une des étiquettes de classe de l'ensemble de données d'apprentissage. Ce bloc-notes montre comment utiliser le API JumpStart pour la classification de texte.

Déployer et exécuter l'inférence sur le modèle pré-entraîné

Le modèle de classification de texte que nous avons choisi d'utiliser repose sur une incorporation de texte (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) modèle de Hub TensorFlow, qui est pré-formé sur les ensembles de données Wikipedia et BookCorpus.

Le modèle disponible pour le déploiement est créé en attachant une couche de classification binaire à la sortie du modèle d'intégration de texte, puis en affinant l'ensemble du modèle sur le SST-2 ensemble de données, qui comprend des critiques de films positives et négatives.

Pour exécuter l'inférence sur ce modèle, nous devons d'abord télécharger le conteneur d'inférence (deploy_image_uri), script d'inférence (deploy_source_uri) et modèle pré-entraîné (base_model_uri). Nous les transmettons ensuite en tant que paramètres pour instancier un objet modèle SageMaker, que nous pouvons ensuite déployer :

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 "

Le code suivant montre nos réponses :

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

Affiner le modèle pré-formé sur un jeu de données personnalisé

Nous venons de parcourir l'exécution de l'inférence sur un modèle BERT pré-formé, qui a été affiné sur le SST-2 jeu de données.

Ensuite, nous expliquons comment affiner un modèle sur un jeu de données personnalisé avec n'importe quel nombre de classes. L'ensemble de données que nous utilisons pour le réglage fin est toujours le SST-2 base de données. Vous pouvez remplacer cet ensemble de données par n'importe quel ensemble de données qui vous intéresse.

Nous récupérons le conteneur Docker d'entraînement, la source de l'algorithme d'entraînement et le modèle pré-entraîné :

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

Pour les hyperparamètres spécifiques à l'algorithme, nous commençons par récupérer un dictionnaire Python des hyperparamètres d'apprentissage que l'algorithme accepte avec leurs valeurs par défaut. Vous pouvez les remplacer par des valeurs personnalisées, comme illustré dans le code suivant :

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"

Le jeu de données (SST-2) est divisé en ensembles d'apprentissage, de validation et de test, où l'ensemble d'apprentissage est utilisé pour ajuster le modèle, l'ensemble de validation est utilisé pour calculer les métriques d'évaluation qui peuvent être utilisées pour HPO, et l'ensemble de test est utilisé comme données retenues pour évaluer les performances du modèle. Ensuite, l'ensemble de données d'entraînement et de validation est chargé sur Amazon S3 et utilisé pour lancer la tâche d'entraînement de réglage fin :

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

Une fois la tâche de réglage fin terminée, nous déployons le modèle, exécutons l'inférence sur l'ensemble de données de test retenu et calculons les métriques d'évaluation. Comme il s'agit d'une tâche de classification binaire, nous utilisons le score de précision ainsi que le Score F1 comme paramètres d'évaluation. Une valeur plus élevée indique de meilleures performances. La capture d'écran suivante montre nos résultats.

Améliorez encore les performances de réglage fin avec le réglage automatique du modèle SageMaker

Dans cette étape, nous montrons comment vous pouvez encore améliorer les performances du modèle en affinant le modèle avec le réglage automatique du modèle SageMaker. Le réglage automatique du modèle, également appelé optimisation des hyperparamètres (HPO), trouve la meilleure version d'un modèle en exécutant plusieurs tâches d'entraînement sur votre jeu de données avec une plage d'hyperparamètres que vous spécifiez. Il choisit ensuite les valeurs d'hyperparamètres qui se traduisent par un modèle qui fonctionne le mieux, tel que mesuré par une métrique que vous choisissez, sur l'ensemble de données de validation.

Tout d'abord, nous définissons l'objectif comme le score de précision sur les données de validation (val_accuracy) et défini des métriques pour la tâche de réglage en spécifiant le nom de la métrique objective et une expression régulière (regex). L'expression régulière est utilisée pour faire correspondre la sortie du journal de l'algorithme et capturer les valeurs numériques des métriques. Ensuite, nous spécifions des plages d'hyperparamètres pour sélectionner les meilleures valeurs d'hyperparamètres. Nous fixons le nombre total de travaux de réglage à six et distribuons ces travaux sur trois différents Cloud de calcul élastique Amazon (Amazon EC2) pour exécuter des tâches de réglage parallèles. Voir le code suivant :

# 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

Nous transmettons ces valeurs pour instancier un objet SageMaker Estimator, similaire à ce que nous avons fait à l'étape précédente de réglage fin. Au lieu d'appeler le fit fonction de la Estimator objet, nous passons le Estimator object in en tant que paramètre de HyperparameterTuner constructeur et appeler le fit fonction de celui-ci pour lancer des travaux de réglage :

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

Une fois les tâches de réglage terminées, nous déployons le modèle qui donne le meilleur score de métrique d'évaluation sur l'ensemble de données de validation, effectuons l'inférence sur le même ensemble de données de test d'exclusion que nous avons fait dans la section précédente et calculons les métriques d'évaluation.

Les résultats montrent que le modèle sélectionné par le réglage automatique du modèle surpasse de manière significative le modèle affiné dans la section précédente sur un jeu de données de test retenu.

Reconnaissance des entités nommées

La reconnaissance d'entités nommées (NER) est le processus de détection et de classification d'entités nommées dans des catégories prédéfinies, telles que les noms de personnes, d'organisations, de lieux et de quantités. Il existe de nombreux cas d'utilisation réels pour NER, tels que les moteurs de recommandation, la catégorisation et l'attribution des tickets d'assistance client au bon service, l'extraction d'informations essentielles des rapports des patients dans le domaine de la santé et la classification du contenu des actualités et des blogs.

Déployer et exécuter l'inférence sur le modèle pré-entraîné

Nous déployons le Fr_core_web_md modèle de la SpaCy bibliothèque. spaCy est une bibliothèque NLP open source qui peut être utilisée pour diverses tâches et possède des méthodes intégrées pour NER. Nous utilisons un AWS PyTorch Deep Learning Container (DLC) avec un mode script et installons la bibliothèque spaCy en tant que dépendance au-dessus du conteneur.

Ensuite, un point d'entrée pour le script (argument entry_point.py) est spécifié, contenant tout le code pour télécharger et charger le En_core_web_md modéliser et effectuer une inférence sur les données envoyées au point de terminaison. Enfin, nous devons encore fournir model_data comme modèle pré-entraîné pour l'inférence. Parce que les pré-formés En_core_web_md modèle est téléchargé à la volée, ce qui est spécifié dans le script d'entrée, nous fournissons un fichier d'archive vide. Une fois le point de terminaison déployé, vous pouvez appeler le point de terminaison directement à partir du bloc-notes à l'aide des SDK SageMaker Python. Predictor. Voir le code suivant:

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

Les données d'entrée du modèle sont un document textuel. Le modèle d'entité nommée extrait des morceaux de nom et des entités nommées dans le document textuel et les classe en un certain nombre de types différents (tels que des personnes, des lieux et des organisations). L'entrée et la sortie d'exemple sont présentées dans le code suivant. La start_char le paramètre indique le décalage de caractère pour le début de la plage, et end_char indique la fin de la plage.

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

Affiner le modèle pré-formé sur un jeu de données personnalisé

Dans cette étape, nous montrons comment affiner un modèle de langage pré-formé pour NER sur votre propre jeu de données. L'étape de réglage fin met à jour les paramètres du modèle pour capturer les caractéristiques de vos propres données et améliorer la précision. Nous utilisons le WikiANN (PAN-X) ensemble de données pour affiner DistilBERT-base-sans boîtier Modèle de transformateur de Hugging Face.

L'ensemble de données est divisé en ensembles d'entraînement, de validation et de test.

Ensuite, nous spécifions les hyperparamètres du modèle, et utilisons un AWS Hugging Face DLC avec un mode script (argument entry_point) pour déclencher la tâche de réglage fin :

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
)

Une fois la tâche de réglage fin terminée, nous déployons un point de terminaison et interrogeons ce point de terminaison avec les données de test retenues. Pour interroger le point de terminaison, chaque chaîne de texte doit être segmentée en un ou plusieurs jetons et envoyée au modèle de transformateur. Chaque jeton obtient une balise d'entité nommée prédite. Étant donné que chaque chaîne de texte peut être segmentée en un ou plusieurs jetons, nous devons dupliquer la balise d'entité nommée vérité terrain de la chaîne sur tous les jetons qui lui sont associés. Le cahier fourni vous guide à travers les étapes pour y parvenir.

Enfin, nous utilisons les métriques d'évaluation intégrées de Hugging Face suite pour calculer des notes d'évaluation sur les données de test d'attente. Les mesures d'évaluation utilisées sont la précision globale, le rappel global, la F1 globale et l'exactitude. La capture d'écran suivante montre nos résultats.

Améliorez encore les performances de réglage fin avec le réglage automatique du modèle SageMaker

Semblable à la classification de texte, nous montrons comment vous pouvez encore améliorer les performances du modèle en affinant le modèle avec le réglage automatique du modèle SageMaker. Pour exécuter la tâche de réglage, nous devons définir une métrique objective que nous voulons utiliser pour évaluer les performances du modèle sur l'ensemble de données de validation (score F1 dans ce cas), des plages d'hyperparamètres pour sélectionner les meilleures valeurs d'hyperparamètres, ainsi que des configurations de tâche de réglage telles que nombre maximal de tâches de réglage et nombre de tâches parallèles à lancer simultanément :

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)

Une fois les tâches de réglage terminées, nous déployons le modèle qui donne le meilleur score de métrique d'évaluation sur l'ensemble de données de validation, effectuons l'inférence sur le même ensemble de données de test d'exclusion que nous avons fait dans la section précédente et calculons les métriques d'évaluation.

Nous pouvons voir que le modèle avec HPO atteint des performances nettement meilleures sur toutes les métriques.

Question répondant

La réponse aux questions est utile lorsque vous souhaitez interroger une grande quantité de texte pour obtenir des informations spécifiques. Il permet à un utilisateur d'exprimer une question en langage naturel et d'obtenir une réponse immédiate et brève. Les systèmes de réponse aux questions alimentés par NLP peuvent être utilisés dans les moteurs de recherche et les interfaces de conversation téléphonique.

Déployer et exécuter l'inférence sur le modèle pré-entraîné

Notre modèle pré-entraîné est le modèle extractive question answering (EQA) bert-large-un-cased-whole-word-masking-finetuned-squad construit sur un modèle Transformer de Hugging Face. Nous utilisons un DLC AWS PyTorch avec un mode script et installons le transformateurs bibliothèque en tant que dépendance au-dessus du conteneur. Semblable à la tâche NER, nous fournissons un fichier d'archive vide dans l'argument model_data car le modèle pré-formé est téléchargé à la volée. Une fois le point de terminaison déployé, vous pouvez appeler le point de terminaison directement à partir du bloc-notes à l'aide des SDK SageMaker Python. Predictor. Voir le code suivant:

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",
    },
)

Tout ce que nous avons à faire est de construire un objet dictionnaire avec deux clés. context est le texte à partir duquel nous souhaitons récupérer des informations. question est la requête en langage naturel qui spécifie les informations que nous souhaitons extraire. Nous appelons predict sur notre prédicteur, et nous devrions obtenir une réponse du point de terminaison qui contient les réponses les plus probables :

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

Nous avons la réponse, et nous pouvons imprimer les réponses les plus probables qui ont été extraites du texte précédent. Chaque réponse a un score de confiance utilisé pour le classement (mais ce score ne doit pas être interprété comme une vraie probabilité). En plus de la réponse textuelle, vous obtenez également les index des caractères de début et de fin de la réponse à partir du contexte d'origine :

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

Maintenant, nous affinons ce modèle avec notre propre ensemble de données personnalisé pour obtenir de meilleurs résultats.

Affiner le modèle pré-formé sur un jeu de données personnalisé

Dans cette étape, nous montrons comment affiner un modèle de langage pré-formé pour l'EQA sur votre propre ensemble de données. L'étape de réglage fin met à jour les paramètres du modèle pour capturer les caractéristiques de vos propres données et améliorer la précision. Nous utilisons le escadron2.0 ensemble de données pour affiner un modèle d'incorporation de texte bert-base-sans boîtier de Visage étreignant. Le modèle disponible pour le réglage fin attache une couche d'extraction de réponse au modèle d'incorporation de texte et initialise les paramètres de la couche à des valeurs aléatoires. L'étape d'affinement affine tous les paramètres du modèle pour minimiser l'erreur de prédiction sur les données d'entrée et renvoie le modèle affiné.

Semblable à la tâche de classification de texte, l'ensemble de données (SQuAD2.0) est divisé en ensemble d'entraînement, de validation et de test.

Ensuite, nous spécifions les hyperparamètres du modèle et utilisons les API JumpStart pour déclencher une tâche de réglage fin :

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)

Une fois la tâche de réglage fin terminée, nous déployons le modèle, exécutons l'inférence sur l'ensemble de données de test retenu et calculons les métriques d'évaluation. Les paramètres d'évaluation utilisés sont le score de correspondance exact moyen et le score F1 moyen. La capture d'écran suivante montre les résultats.

Améliorez encore les performances de réglage fin avec le réglage automatique du modèle SageMaker

Comme dans les sections précédentes, nous utilisons un HyperparameterTuner objet pour lancer les tâches de réglage :

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

Une fois les tâches de réglage terminées, nous déployons le modèle qui donne le meilleur score de métrique d'évaluation sur l'ensemble de données de validation, effectuons l'inférence sur le même ensemble de données de test d'exclusion que nous avons fait dans la section précédente et calculons les métriques d'évaluation.

Nous pouvons voir que le modèle avec HPO montre une performance significativement meilleure sur les données de test de retenue.

Extraction de relations

L'extraction de relations consiste à extraire des relations sémantiques du texte, qui se produisent généralement entre deux ou plusieurs entités. L'extraction de relations joue un rôle important dans l'extraction d'informations structurées à partir de sources non structurées telles que du texte brut. Dans ce bloc-notes, nous illustrons deux cas d'utilisation de l'extraction de relations.

Affiner le modèle pré-formé sur un jeu de données personnalisé

Nous utilisons un modèle d'extraction de relations construit sur un Base BERT sans boîtier modèle utilisant des transformateurs Transformateurs de visage étreignant bibliothèque. Le modèle de réglage fin attache une couche de classification linéaire qui prend une paire d'incorporations de jetons générées par le modèle d'incorporation de texte et initialise les paramètres de couche à des valeurs aléatoires. L'étape d'affinement affine tous les paramètres du modèle pour minimiser l'erreur de prédiction sur les données d'entrée et renvoie le modèle affiné.

L'ensemble de données que nous affinons le modèle est SemEval-2010 Tâche 8. Le modèle renvoyé par le réglage fin peut être déployé davantage pour l'inférence.

L'ensemble de données contient des ensembles d'entraînement, de validation et de test.

Nous utilisons le DLC AWS PyTorch avec un mode script du SDK Python SageMaker, où le transformers bibliothèque est installée en tant que dépendance au-dessus du conteneur. Nous définissons le SageMaker PyTorch estimateur et un ensemble d'hyperparamètres tels que le modèle pré-formé, le taux d'apprentissage et les nombres d'époques pour effectuer le réglage fin. Le code permettant d'affiner le modèle d'extraction de relations est défini dans le entry_point.py. Voir le code suivant:

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/",
    }
)

Améliorez encore les performances de réglage fin avec le réglage automatique du modèle SageMaker

Comme dans les sections précédentes, nous utilisons un HyperparameterTuner objet pour interagir avec les API de réglage d'hyperparamètres SageMaker. Nous pouvons démarrer le travail de réglage des hyperparamètres en appelant le fit méthode:

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/",
})

Lorsque la tâche de réglage des hyperparamètres est terminée, nous effectuons une inférence et vérifions le score d'évaluation.

Nous pouvons voir que le modèle avec HPO montre de meilleures performances sur les données de test retenues.

Résumé des documents

Le résumé de document ou de texte consiste à condenser de grandes quantités de données textuelles en un sous-ensemble plus petit de phrases significatives qui représentent les informations les plus importantes ou les plus pertinentes du contenu original. Le résumé de document est une technique utile pour distiller des informations importantes à partir de grandes quantités de données textuelles en quelques phrases. Le résumé de texte est utilisé dans de nombreux cas d'utilisation, tels que le traitement de documents et l'extraction d'informations à partir de blogs, d'articles et d'actualités.

Ce bloc-notes illustre le déploiement du modèle de synthèse de document Base T5 du Transformateurs de visage étreignant bibliothèque. Nous testons également les points de terminaison déployés à l'aide d'un article de texte et évaluons les résultats à l'aide de la métrique d'évaluation intégrée Hugging Face. ROUGE.

Semblable aux cahiers de questions-réponses et NER, nous utilisons le PyTorchModel du SDK Python SageMaker avec un entry_point.py script pour charger le modèle de base T5 sur un point de terminaison HTTPS. Une fois le point de terminaison déployé avec succès, nous pouvons envoyer un article texte au point de terminaison pour obtenir une réponse de prédiction :

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

Ensuite, nous évaluons et comparons l'article texte et le résultat du résumé à l'aide de la métrique ROUGE. Trois mesures d'évaluation sont calculées : rougeN, rougeL ainsi que rougeLsum. rougeN mesure le nombre de correspondances n-grams entre le texte généré par le modèle (résultat du résumé) et un reference (Texte de saisie). Les métriques rougeL ainsi que le rougeLsum mesurer les séquences de mots correspondantes les plus longues en recherchant les sous-chaînes communes les plus longues dans les résumés générés et de référence. Pour chaque métrique, les intervalles de confiance pour la précision, le rappel et le score F1 sont calculés. Voir le code suivant :

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

Nettoyer

Les ressources créées pour cette solution peuvent être supprimées à l'aide de la Supprimer toutes les ressources bouton de l'IDE SageMaker Studio. Chaque bloc-notes fournit également une section de nettoyage avec le code pour supprimer les points de terminaison.

Conclusion

Dans cet article, nous avons montré comment utiliser des techniques ML de pointe pour résoudre cinq tâches NLP différentes : résumé de documents, classification de texte, questions et réponses, reconnaissance d'entités nommées et extraction de relations à l'aide de Jumpstart. Commencez dès maintenant avec Jumpstart!

À propos des auteurs

Dr Xin Huang est un scientifique appliqué pour Amazon SageMaker JumpStart et les algorithmes intégrés d'Amazon SageMaker. Il se concentre sur le développement d'algorithmes d'apprentissage automatique évolutifs. Ses intérêts de recherche portent sur le traitement du langage naturel, l'apprentissage en profondeur explicable sur des données tabulaires et l'analyse robuste du clustering spatio-temporel non paramétrique. Il a publié de nombreux articles dans les conférences ACL, ICDM, KDD et Royal Statistical Society: Series A journal.

Vivek Gangasani est architecte principal de solutions d'apprentissage automatique chez Amazon Web Services. Il aide les startups à créer et à opérationnaliser des applications AI/ML. Il se concentre actuellement sur la combinaison de son expérience dans les conteneurs et l'apprentissage automatique pour fournir des solutions sur MLOps, ML Inference et ML low-code. Dans ses temps libres, il aime essayer de nouveaux restaurants et explorer les tendances émergentes en matière d'IA et d'apprentissage en profondeur.

Gérémy Cohen est un architecte de solutions chez AWS, où il aide les clients à créer des solutions cloud de pointe. Dans ses temps libres, il aime faire de courtes promenades sur la plage, explorer la baie avec sa famille, réparer les choses autour de la maison, casser des choses autour de la maison et faire des barbecues.

Neelam Koshiya est un architecte de solutions d'entreprise chez AWS. Son objectif actuel est d'aider les entreprises clientes dans leur parcours d'adoption du cloud pour des résultats commerciaux stratégiques. Dans ses temps libres, elle aime lire et être à l'extérieur.