Identifizieren Sie wichtige Erkenntnisse aus Textdokumenten durch Feinabstimmung und HPO mit Amazon SageMaker JumpStart

Organisationen aus verschiedenen Branchen wie Einzelhandel, Banken, Finanzen, Gesundheitswesen, Fertigung und Kreditvergabe müssen sich oft mit riesigen Mengen an unstrukturierten Textdokumenten auseinandersetzen, die aus verschiedenen Quellen wie Nachrichten, Blogs, Produktbewertungen, Kundensupportkanälen und sozialen Medien stammen. Diese Dokumente enthalten wichtige Informationen, die für wichtige Geschäftsentscheidungen von entscheidender Bedeutung sind. Wenn eine Organisation wächst, wird es zu einer Herausforderung, wichtige Informationen aus diesen Dokumenten zu extrahieren. Mit der Weiterentwicklung der Techniken zur Verarbeitung natürlicher Sprache (NLP) und des maschinellen Lernens (ML) können wir schnell und mit hoher Genauigkeit wertvolle Erkenntnisse und Verbindungen aus diesen Textdokumenten aufdecken und Unternehmen dabei helfen, rechtzeitig qualitativ hochwertige Geschäftsentscheidungen zu treffen. Vollständig verwaltete NLP-Dienste haben auch die Einführung von NLP beschleunigt. Amazon verstehen ist ein vollständig verwalteter Service, mit dem Sie benutzerdefinierte NLP-Modelle erstellen können, die speziell auf Ihre Anforderungen zugeschnitten sind, ohne dass ML-Expertise erforderlich ist.

In diesem Beitrag zeigen wir, wie Sie modernste ML-Techniken einsetzen, um fünf verschiedene NLP-Aufgaben zu lösen: Dokumentenzusammenfassung, Textklassifizierung, Beantwortung von Fragen, Erkennung benannter Entitäten und Beziehungsextraktion. Für jede dieser NLP-Aufgaben demonstrieren wir die Verwendung Amazon Sage Maker um die folgenden Aktionen auszuführen:

• Bereitstellen und Ausführen von Inferenzen für ein vorab trainiertes Modell
• Optimieren Sie das vortrainierte Modell auf einem neuen benutzerdefinierten Dataset
• Verbessern Sie die Feinabstimmungsleistung weiter mit Automatische Modellabstimmung von SageMaker
• Bewerten Sie die Modellleistung anhand der Holdout-Testdaten mit verschiedenen Bewertungsmetriken

Obwohl wir in diesem Beitrag fünf spezifische NLP-Aufgaben behandeln, können Sie diese Lösung als Vorlage verwenden, um die Feinabstimmung vortrainierter Modelle mit Ihrem eigenen Datensatz zu verallgemeinern und anschließend eine Hyperparameter-Optimierung durchzuführen, um die Genauigkeit zu verbessern.

JumpStart-Lösungsvorlagen

Amazon SageMaker-JumpStart bietet One-Click-End-to-End-Lösungen für viele gängige ML-Anwendungsfälle. Sehen Sie sich die folgenden Anwendungsfälle an, um weitere Informationen zu verfügbaren Lösungsvorlagen zu erhalten:

Die JumpStart-Lösungsvorlagen decken eine Vielzahl von Anwendungsfällen ab, unter denen jeweils mehrere verschiedene Lösungsvorlagen angeboten werden (diese Document Understanding-Lösung befindet sich unter dem Anwendungsfall „Daten aus Dokumenten extrahieren und analysieren“).

Wählen Sie auf der Landingpage von JumpStart die Lösungsvorlage aus, die am besten zu Ihrem Anwendungsfall passt. Weitere Informationen zu spezifischen Lösungen für jeden Anwendungsfall und zum Starten einer JumpStart-Lösung finden Sie unter Lösungsvorlagen.

Lösungsüberblick

Das folgende Bild zeigt, wie Sie diese Lösung mit SageMaker-Komponenten verwenden können. Die SageMaker-Trainingsjobs werden verwendet, um die verschiedenen NLP-Modelle zu trainieren, und SageMaker-Endpunkte werden verwendet, um die Modelle in jeder Phase bereitzustellen. Wir gebrauchen Amazon Simple Storage-Service (Amazon S3) neben SageMaker zum Speichern der Trainingsdaten und Modellartefakte und Amazon CloudWatch zum Protokollieren von Trainings- und Endpunktausgaben.

Öffnen Sie die Document Understanding-Lösung

Navigieren Sie in JumpStart zur Document Understanding-Lösung.

Jetzt können wir uns einige der Assets, die in dieser Lösung enthalten sind, genauer ansehen, beginnend mit dem Demo-Notebook.

Demo-Notizbuch

Sie können das Demo-Notebook verwenden, um Beispieldaten an bereits bereitgestellte Modellendpunkte für die Dokumentenzusammenfassung und die Aufgaben zur Beantwortung von Fragen zu senden. Mit dem Demo-Notebook können Sie schnell praktische Erfahrungen sammeln, indem Sie die Beispieldaten abfragen.

Nachdem Sie die Document Understanding-Lösung gestartet haben, öffnen Sie das Demo-Notebook, indem Sie auswählen Verwenden Sie Endpunkt in Notebook.

Lassen Sie uns tiefer in jedes der fünf Hauptnotebooks für diese Lösung eintauchen.

Voraussetzungen:

In Amazon SageMaker-Studio, stellen Sie sicher, dass Sie die verwenden PyTorch 1.10 Python 3.8 CPU Optimized image/kernel, um die Notizbücher zu öffnen. Das Training verwendet fünf ml.g4dn.2xlarge-Instanzen, also sollten Sie a erhöhen Anforderung zur Erhöhung des Servicelimits wenn Ihr Konto erhöhte Limits für diesen Typ erfordert.

Textklassifizierung

Textklassifikation bezieht sich auf die Klassifikation eines Eingabesatzes in eine der Klassenbezeichnungen des Trainingsdatensatzes. Dieses Notebook demonstriert die Verwendung des JumpStart-API zur Textklassifizierung.

Stellen Sie die Inferenz für das vorab trainierte Modell bereit und führen Sie sie aus

Das von uns gewählte Textklassifizierungsmodell basiert auf einer Texteinbettung (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) Modell aus TensorFlow-Hub, das auf Wikipedia- und BookCorpus-Datensätzen vortrainiert ist.

Das für die Bereitstellung verfügbare Modell wird erstellt, indem eine binäre Klassifizierungsebene an die Ausgabe des Texteinbettungsmodells angehängt wird und dann das gesamte Modell auf der verfeinert wird SST-2 Datensatz, der aus positiven und negativen Filmkritiken besteht.

Um die Inferenz für dieses Modell auszuführen, müssen wir zuerst den Inferenzcontainer (deploy_image_uri), Inferenzskript (deploy_source_uri) und vortrainiertes Modell (base_model_uri). Wir übergeben diese dann als Parameter, um ein SageMaker-Modellobjekt zu instanziieren, das wir dann bereitstellen können:

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 "

Der folgende Code zeigt unsere Antworten:

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

Optimieren Sie das vortrainierte Modell anhand eines benutzerdefinierten Datasets

Wir haben gerade die laufende Inferenz auf einem vortrainierten BERT-Modell durchlaufen, das auf dem feinabgestimmt wurde SST-2 Datensatz.

Als Nächstes erörtern wir, wie Sie ein Modell für ein benutzerdefiniertes Dataset mit einer beliebigen Anzahl von Klassen optimieren können. Der Datensatz, den wir für die Feinabstimmung verwenden, ist immer noch der SST-2 Datensatz. Sie können dieses Dataset durch ein beliebiges Dataset ersetzen, an dem Sie interessiert sind.

Wir rufen den Trainings-Docker-Container, die Quelle des Trainingsalgorithmus und das vortrainierte Modell ab:

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

Für algorithmenspezifische Hyperparameter beginnen wir mit dem Abrufen eines Python-Wörterbuchs der Trainings-Hyperparameter, die der Algorithmus mit ihren Standardwerten akzeptiert. Sie können sie mit benutzerdefinierten Werten überschreiben, wie im folgenden Code gezeigt:

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"

Der Datensatz (SST-2) ist in Trainings-, Validierungs- und Testdatensätze unterteilt, wobei der Trainingsdatensatz verwendet wird, um das Modell anzupassen, der Validierungsdatensatz verwendet wird, um Bewertungsmetriken zu berechnen, die für HPO verwendet werden können, und der Testdatensatz als Hold-out-Daten verwendet wird zur Bewertung der Modellleistung. Als Nächstes werden der Trainings- und der Validierungsdatensatz in Amazon S3 hochgeladen und zum Starten des Trainingsauftrags zur Feinabstimmung verwendet:

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

Nachdem die Feinabstimmung abgeschlossen ist, stellen wir das Modell bereit, führen eine Inferenz auf dem zurückgehaltenen Testdatensatz aus und berechnen Bewertungsmetriken. Da es sich um eine binäre Klassifizierungsaufgabe handelt, verwenden wir die Genauigkeitspunktzahl machen F1-Punktzahl als Bewertungsmaßstab. Ein größerer Wert zeigt die bessere Leistung an. Der folgende Screenshot zeigt unsere Ergebnisse.

Verbessern Sie die Feinabstimmungsleistung mit der automatischen Modellabstimmung von SageMaker weiter

In diesem Schritt demonstrieren wir, wie Sie die Modellleistung weiter verbessern können, indem Sie das Modell mit der automatischen Modelloptimierung von SageMaker optimieren. Die automatische Modelloptimierung, auch bekannt als Hyperparameter-Optimierung (HPO), findet die beste Version eines Modells, indem mehrere Trainingsjobs auf Ihrem Dataset mit einer Reihe von Hyperparametern ausgeführt werden, die Sie angeben. Anschließend werden die Hyperparameterwerte ausgewählt, die zu einem Modell führen, das gemessen an einer von Ihnen ausgewählten Metrik im Validierungsdatensatz die beste Leistung erbringt.

Zuerst legen wir das Ziel als Genauigkeitswert für die Validierungsdaten fest (val_accuracy) und definierte Metriken für den Optimierungsjob, indem Sie den Namen der Zielmetrik und einen regulären Ausdruck (regex) angeben. Der reguläre Ausdruck wird verwendet, um die Protokollausgabe des Algorithmus abzugleichen und die numerischen Werte von Metriken zu erfassen. Als Nächstes geben wir Hyperparameterbereiche an, aus denen die besten Hyperparameterwerte ausgewählt werden. Wir setzen die Gesamtzahl der Tuning-Jobs auf sechs und verteilen diese Jobs auf drei verschiedene Amazon Elastic Compute-Cloud (Amazon EC2)-Instances zum Ausführen paralleler Tuning-Jobs. Siehe folgenden Code:

# 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

Wir übergeben diese Werte, um ein SageMaker Estimator-Objekt zu instanziieren, ähnlich wie im vorherigen Feinabstimmungsschritt. Anstatt anzurufen fit Funktion des Estimator Objekt übergeben wir die Estimator Objekt in als Parameter für die HyperparameterTuner Konstruktor und rufen Sie die auf fit Funktion zum Starten von Tuning-Jobs:

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

Nachdem die Optimierungsjobs abgeschlossen sind, stellen wir das Modell bereit, das die beste Bewertungsmetrik für das Validierungsdataset liefert, führen eine Inferenz für dasselbe Hold-out-Testdataset durch, das wir im vorherigen Abschnitt durchgeführt haben, und berechnen Bewertungsmetriken.

Die Ergebnisse zeigen, dass das durch die automatische Modelloptimierung ausgewählte Modell das im vorherigen Abschnitt auf einem Hold-out-Testdatensatz fein abgestimmte Modell deutlich übertrifft.

Erkennung benannter Entitäten

Named Entity Recognition (NER) ist der Prozess der Erkennung und Klassifizierung benannter Entitäten in vordefinierte Kategorien, wie Namen von Personen, Organisationen, Orten und Mengen. Es gibt viele praktische Anwendungsfälle für NER, z. B. Empfehlungsmaschinen, Kategorisierung und Zuweisung von Kundensupport-Tickets an die richtige Abteilung, Extrahieren wesentlicher Informationen aus Patientenberichten im Gesundheitswesen und Inhaltsklassifizierung aus Nachrichten und Blogs.

Stellen Sie die Inferenz für das vorab trainierte Modell bereit und führen Sie sie aus

Wir setzen die ein En_core_web_md Modell aus dem geräumig Bibliothek. spaCy ist eine Open-Source-NLP-Bibliothek, die für verschiedene Aufgaben verwendet werden kann und über integrierte Methoden für NER verfügt. Wir verwenden einen AWS PyTorch Deep Learning Container (DLC) mit einem Skriptmodus und installieren die spaCy-Bibliothek als Abhängigkeit auf dem Container.

Als nächstes wird ein Einstiegspunkt für das Skript (argument entry_point.py) angegeben ist und den gesamten Code zum Herunterladen und Laden enthält En_core_web_md modellieren und Rückschlüsse auf die Daten ziehen, die an den Endpunkt gesendet werden. Schließlich müssen wir noch versorgen model_data als das vortrainierte Modell für die Inferenz. Denn die Vortrainierten En_core_web_md model on the fly heruntergeladen wird, was im Eingabeskript angegeben ist, stellen wir eine leere Archivdatei bereit. Nachdem der Endpunkt bereitgestellt wurde, können Sie den Endpunkt mithilfe der SageMaker-Python-SDKs direkt vom Notebook aus aufrufen Predictor. Siehe folgenden Code:

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

Die Eingabedaten für das Modell sind ein Textdokument. Das benannte Entitätsmodell extrahiert Substantivstücke und benannte Entitäten im Textdokument und klassifiziert sie in eine Reihe unterschiedlicher Typen (wie Personen, Orte und Organisationen). Die Beispieleingabe und -ausgabe sind im folgenden Code dargestellt. Das start_char Parameter gibt den Zeichen-Offset für den Beginn der Spanne an, und end_char zeigt das Ende der Spanne an.

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

Optimieren Sie das vortrainierte Modell anhand eines benutzerdefinierten Datasets

In diesem Schritt demonstrieren wir, wie Sie ein vortrainiertes Sprachmodell für NER an Ihrem eigenen Datensatz optimieren können. Der Feinabstimmungsschritt aktualisiert die Modellparameter, um die Charakteristik Ihrer eigenen Daten zu erfassen und die Genauigkeit zu verbessern. Wir benutzen das WikiANN (PAN-X)-Datensatz zur Feinabstimmung der DestilBERT-Basis-unverpackt Transformer-Modell von Hugging Face.

Der Datensatz ist in Trainings-, Validierungs- und Testsätze aufgeteilt.

Als Nächstes spezifizieren wir die Hyperparameter des Modells und verwenden einen AWS Hugging Face DLC mit einem Skriptmodus (Argument entry_point), um den Fine-Tuning-Job auszulösen:

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
)

Nachdem die Feinabstimmung abgeschlossen ist, stellen wir einen Endpunkt bereit und fragen diesen Endpunkt mit den Hold-out-Testdaten ab. Um den Endpunkt abzufragen, muss jede Textzeichenfolge in ein oder mehrere Token umgewandelt und an das Transformer-Modell gesendet werden. Jedes Token erhält ein vorhergesagtes benanntes Entitäts-Tag. Da jede Textzeichenfolge in ein oder mehrere Token tokenisiert werden kann, müssen wir das Ground Truth benannte Entity-Tag der Zeichenfolge für alle damit verknüpften Token duplizieren. Das bereitgestellte Notizbuch führt Sie durch die Schritte, um dies zu erreichen.

Schließlich verwenden wir die integrierten Bewertungsmetriken von Hugging Face Folge um Bewertungsergebnisse für die Hold-Out-Testdaten zu berechnen. Die verwendeten Bewertungsmetriken sind Gesamtpräzision, Gesamterinnerung, Gesamt-F1 und Genauigkeit. Der folgende Screenshot zeigt unsere Ergebnisse.

Verbessern Sie die Feinabstimmungsleistung mit der automatischen Modellabstimmung von SageMaker weiter

Ähnlich wie bei der Textklassifizierung demonstrieren wir, wie Sie die Modellleistung weiter verbessern können, indem Sie das Modell mit der automatischen Modelloptimierung von SageMaker optimieren. Um den Tuning-Job auszuführen, müssen wir eine objektive Metrik definieren, die wir für die Bewertung der Modellleistung im Validierungsdatensatz verwenden möchten (in diesem Fall F1-Score), Hyperparameterbereiche zur Auswahl der besten Hyperparameterwerte sowie Jobkonfigurationen wie z Maximale Anzahl von Tuning-Jobs und Anzahl paralleler Jobs, die gleichzeitig gestartet werden können:

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)

Nachdem die Optimierungsjobs abgeschlossen sind, stellen wir das Modell bereit, das die beste Bewertungsmetrik für das Validierungsdataset liefert, führen eine Inferenz für dasselbe Hold-out-Testdataset durch, das wir im vorherigen Abschnitt durchgeführt haben, und berechnen Bewertungsmetriken.

Wir können sehen, dass das Modell mit HPO über alle Metriken hinweg eine deutlich bessere Leistung erzielt.

Frage beantworten

Die Beantwortung von Fragen ist nützlich, wenn Sie eine große Textmenge nach bestimmten Informationen abfragen möchten. Es ermöglicht einem Benutzer, eine Frage in natürlicher Sprache zu äußern und eine sofortige und kurze Antwort zu erhalten. Von NLP betriebene Fragebeantwortungssysteme können in Suchmaschinen und Telefongesprächsschnittstellen verwendet werden.

Stellen Sie die Inferenz für das vorab trainierte Modell bereit und führen Sie sie aus

Unser vortrainiertes Modell ist das Extractive Question Answering (EQA)-Modell bert-large-uncased-ganzes-wort-maskierung-finetuned-squad basierend auf einem Transformer-Modell von Hugging Face. Wir verwenden einen AWS PyTorch DLC mit einem Skriptmodus und installieren den Transformer Bibliothek als Abhängigkeit über dem Container. Ähnlich wie bei der NER-Aufgabe stellen wir im Argument eine leere Archivdatei bereit model_data da das vortrainierte Modell on-the-fly heruntergeladen wird. Nachdem der Endpunkt bereitgestellt wurde, können Sie den Endpunkt mithilfe der SageMaker-Python-SDKs direkt vom Notebook aus aufrufen Predictor. Siehe folgenden Code:

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

Alles, was wir tun müssen, ist ein Dictionary-Objekt mit zwei Schlüsseln zu konstruieren. context ist der Text, aus dem wir Informationen abrufen möchten. question ist die Abfrage in natürlicher Sprache, die angibt, welche Informationen wir extrahieren möchten. Wir nennen predict auf unserem Prädiktor, und wir sollten eine Antwort von dem Endpunkt erhalten, der die wahrscheinlichsten Antworten enthält:

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

Wir haben die Antwort und können die wahrscheinlichsten Antworten ausdrucken, die aus dem vorhergehenden Text extrahiert wurden. Jede Antwort hat einen Konfidenzwert, der für das Ranking verwendet wird (aber dieser Wert sollte nicht als wahre Wahrscheinlichkeit interpretiert werden). Neben der wörtlichen Antwort erhalten Sie auch die Start- und Endzeichen-Indizes der Antwort aus dem ursprünglichen Kontext:

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

Jetzt optimieren wir dieses Modell mit unserem eigenen benutzerdefinierten Datensatz, um bessere Ergebnisse zu erzielen.

Optimieren Sie das vortrainierte Modell anhand eines benutzerdefinierten Datasets

In diesem Schritt demonstrieren wir, wie Sie ein vortrainiertes Sprachmodell für EQA an Ihrem eigenen Datensatz optimieren. Der Feinabstimmungsschritt aktualisiert die Modellparameter, um die Charakteristik Ihrer eigenen Daten zu erfassen und die Genauigkeit zu verbessern. Wir benutzen das SQuAD2.0 Datensatz zur Feinabstimmung eines Texteinbettungsmodells bert-base-uncased von Hugging Face. Das für die Feinabstimmung verfügbare Modell fügt eine Antwortextraktionsschicht an das Texteinbettungsmodell an und initialisiert die Schichtparameter auf zufällige Werte. Der Feinabstimmungsschritt stimmt alle Modellparameter ab, um den Vorhersagefehler bei den Eingabedaten zu minimieren, und gibt das feinabgestimmte Modell zurück.

Ähnlich wie bei der Textklassifikationsaufgabe wird der Datensatz (SQuAD2.0) in Trainings-, Validierungs- und Testsatz aufgeteilt.

Als nächstes spezifizieren wir die Hyperparameter des Modells und verwenden die JumpStart-API um einen Fine-Tuning-Job auszulösen:

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)

Nachdem die Feinabstimmung abgeschlossen ist, stellen wir das Modell bereit, führen eine Inferenz auf dem zurückgehaltenen Testdatensatz aus und berechnen Bewertungsmetriken. Die verwendeten Bewertungsmetriken sind die durchschnittliche exakte Übereinstimmungspunktzahl und die durchschnittliche F1-Punktzahl. Der folgende Screenshot zeigt die Ergebnisse.

Verbessern Sie die Feinabstimmungsleistung mit der automatischen Modellabstimmung von SageMaker weiter

Ähnlich wie in den vorherigen Abschnitten verwenden wir a HyperparameterTuner Objekt zum Starten von Tuning-Jobs:

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

Nachdem die Optimierungsjobs abgeschlossen sind, stellen wir das Modell bereit, das die beste Bewertungsmetrik für das Validierungsdataset liefert, führen eine Inferenz für dasselbe Hold-out-Testdataset durch, das wir im vorherigen Abschnitt durchgeführt haben, und berechnen Bewertungsmetriken.

Wir können sehen, dass das Modell mit HPO eine deutlich bessere Leistung bei den Hold-out-Testdaten zeigt.

Extraktion von Beziehungen

Beziehungsextraktion ist die Aufgabe, semantische Beziehungen aus Text zu extrahieren, die normalerweise zwischen zwei oder mehr Entitäten auftreten. Die Beziehungsextraktion spielt eine wichtige Rolle beim Extrahieren strukturierter Informationen aus unstrukturierten Quellen wie Rohtext. In diesem Notebook demonstrieren wir zwei Anwendungsfälle der Beziehungsextraktion.

Optimieren Sie das vortrainierte Modell anhand eines benutzerdefinierten Datasets

Wir verwenden ein Beziehungsextraktionsmodell, das auf a BERT-Sockel-ohne Gehäuse Modell mit Transformatoren aus der Hugging Face-Transformatoren Bibliothek. Das Modell für die Feinabstimmung fügt eine lineare Klassifizierungsschicht hinzu, die ein Paar von Token-Einbettungen nimmt, die vom Texteinbettungsmodell ausgegeben werden, und die Schichtparameter auf zufällige Werte initialisiert. Der Feinabstimmungsschritt stimmt alle Modellparameter ab, um den Vorhersagefehler bei den Eingabedaten zu minimieren, und gibt das feinabgestimmte Modell zurück.

Der Datensatz, an dem wir das Modell optimieren, ist SemEval-2010 Aufgabe 8. Das durch die Feinabstimmung zurückgegebene Modell kann für die Inferenz weiter eingesetzt werden.

Das Dataset enthält Trainings-, Validierungs- und Testsets.

Wir verwenden den AWS PyTorch DLC mit einem Skriptmodus aus dem SageMaker Python SDK, wobei die transformers Die Bibliothek wird als Abhängigkeit über dem Container installiert. Wir definieren den SageMaker PyTorch Schätzer und eine Reihe von Hyperparametern wie das vortrainierte Modell, die Lernrate und die Epochennummern, um die Feinabstimmung durchzuführen. Der Code für die Feinabstimmung des Beziehungsextraktionsmodells ist in definiert entry_point.py. Siehe folgenden Code:

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

Verbessern Sie die Feinabstimmungsleistung mit der automatischen Modellabstimmung von SageMaker weiter

Ähnlich wie in den vorherigen Abschnitten verwenden wir a HyperparameterTuner -Objekt, um mit SageMaker-APIs zur Hyperparameter-Optimierung zu interagieren. Wir können den Hyperparameter-Tuning-Job starten, indem wir die aufrufen fit Verfahren:

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

Wenn der Hyperparameter-Tuning-Job abgeschlossen ist, führen wir eine Inferenz durch und überprüfen die Bewertungspunktzahl.

Wir können sehen, dass das Modell mit HPO eine bessere Leistung bei den Hold-out-Testdaten zeigt.

Dokumentenzusammenfassung

Die Dokument- oder Textzusammenfassung ist die Aufgabe, große Mengen an Textdaten zu einer kleineren Teilmenge aussagekräftiger Sätze zu verdichten, die die wichtigsten oder relevantesten Informationen innerhalb des ursprünglichen Inhalts darstellen. Die Dokumentenzusammenfassung ist eine nützliche Technik, um wichtige Informationen aus großen Mengen von Textdaten in wenige Sätze zu destillieren. Die Textzusammenfassung wird in vielen Anwendungsfällen verwendet, z. B. bei der Dokumentenverarbeitung und dem Extrahieren von Informationen aus Blogs, Artikeln und Nachrichten.

Dieses Notebook demonstriert die Bereitstellung des Dokumentzusammenfassungsmodells T5-Basis von dem Hugging Face-Transformatoren Bibliothek. Wir testen die bereitgestellten Endpunkte auch mithilfe eines Textartikels und bewerten die Ergebnisse mithilfe der integrierten Bewertungsmetrik „Hugging Face“. ROT.

Ähnlich wie bei den Fragebeantwortungs- und NER-Notizbüchern verwenden wir die PyTorchModel aus dem SageMaker Python SDK zusammen mit einer entry_point.py -Skript zum Laden des T5-Basismodells auf einen HTTPS-Endpunkt. Nachdem der Endpunkt erfolgreich bereitgestellt wurde, können wir einen Textartikel an den Endpunkt senden, um eine Vorhersageantwort zu erhalten:

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

Als nächstes bewerten und vergleichen wir den Textartikel und das Zusammenfassungsergebnis unter Verwendung der ROUGE-Metrik. Es werden drei Bewertungsmetriken berechnet: rougeN, rougeL und rougeLsum. rougeN misst die Anzahl der Übereinstimmungen n-grams zwischen dem modellgenerierten Text (Zusammenfassungsergebnis) und a reference (Eingabetext). Die Metriken rougeL machen rougeLsum Messen Sie die längsten übereinstimmenden Wortfolgen, indem Sie in den generierten und Referenzzusammenfassungen nach den längsten gemeinsamen Teilzeichenfolgen suchen. Für jede Metrik werden Konfidenzintervalle für Präzision, Erinnerung und F1-Punktzahl berechnet. Siehe folgenden Code:

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

Aufräumen

Ressourcen, die für diese Lösung erstellt wurden, können mit gelöscht werden Löschen Sie alle Ressourcen Schaltfläche aus der SageMaker Studio IDE. Jedes Notebook bietet auch einen Bereinigungsabschnitt mit dem Code zum Löschen der Endpunkte.

Zusammenfassung

In diesem Beitrag haben wir gezeigt, wie modernste ML-Techniken eingesetzt werden können, um fünf verschiedene NLP-Aufgaben zu lösen: Dokumentenzusammenfassung, Textklassifizierung, Fragen und Antworten, Erkennung benannter Entitäten und Beziehungsextraktion mit Jumpstart. Starten Sie jetzt mit Jumpstart!

Über die Autoren

Xin Huang ist ein angewandter Wissenschaftler für Amazon SageMaker JumpStart und die integrierten Algorithmen von Amazon SageMaker. Er konzentriert sich auf die Entwicklung skalierbarer Algorithmen für maschinelles Lernen. Seine Forschungsinteressen liegen im Bereich der Verarbeitung natürlicher Sprache, erklärbares Deep Learning auf tabellarischen Daten und robuste Analyse von nichtparametrischem Raum-Zeit-Clustering. Er hat viele Artikel in ACL-, ICDM-, KDD-Konferenzen und in der Zeitschrift Royal Statistical Society: Series A veröffentlicht.

Vivek Gangasani ist Senior Machine Learning Solutions Architect bei Amazon Web Services. Er hilft Startups beim Aufbau und der Operationalisierung von KI/ML-Anwendungen. Derzeit konzentriert er sich darauf, seinen Hintergrund in Containern und maschinellem Lernen zu kombinieren, um Lösungen für MLOps, ML-Inferenz und Low-Code-ML bereitzustellen. In seiner Freizeit probiert er gerne neue Restaurants aus und erforscht neue Trends in den Bereichen KI und Deep Learning.

Geremy Cohen ist ein Lösungsarchitekt bei AWS, bei dem er Kunden bei der Entwicklung innovativer Cloud-basierter Lösungen unterstützt. In seiner Freizeit genießt er kurze Strandspaziergänge, erkundet mit seiner Familie die Bucht, repariert Dinge rund um das Haus, bricht Dinge rund um das Haus und grillt.

Neelam Koshiya ist ein Enterprise Solution Architect bei AWS. Ihr aktueller Fokus liegt darauf, Unternehmenskunden bei ihrer Cloud-Einführung für strategische Geschäftsergebnisse zu unterstützen. In ihrer Freizeit liest sie gerne und ist gerne im Freien.