Identificer nøgleindsigt fra tekstdokumenter gennem finjustering og HPO med Amazon SageMaker JumpStart

Organisationer på tværs af brancher såsom detailhandel, bank, finans, sundhedspleje, produktion og udlån skal ofte håndtere enorme mængder af ustrukturerede tekstdokumenter, der kommer fra forskellige kilder, såsom nyheder, blogs, produktanmeldelser, kundesupportkanaler og sociale medier. Disse dokumenter indeholder kritisk information, der er nøglen til at træffe vigtige forretningsbeslutninger. Efterhånden som en organisation vokser, bliver det en udfordring at udtrække kritisk information fra disse dokumenter. Med udviklingen af ​​naturlig sprogbehandling (NLP) og maskinlæring (ML) teknikker kan vi afdække værdifuld indsigt og forbindelser fra disse tekstdokumenter hurtigt og med høj nøjagtighed, og derved hjælpe virksomheder med at træffe kvalitetsforretningsbeslutninger til tiden. Fuldt administrerede NLP-tjenester har også fremskyndet vedtagelsen af ​​NLP. Amazon Comprehend er en fuldt administreret tjeneste, der giver dig mulighed for at bygge skræddersyede NLP-modeller, der er specifikke for dine krav, uden behov for nogen ML-ekspertise.

I dette indlæg demonstrerer vi, hvordan man bruger avancerede ML-teknikker til at løse fem forskellige NLP-opgaver: dokumentopsummering, tekstklassificering, besvarelse af spørgsmål, genkendelse af navngivne enheder og udtrækning af relationer. For hver af disse NLP-opgaver demonstrerer vi, hvordan man bruger Amazon SageMaker for at udføre følgende handlinger:

• Implementer og kør inferens på en præ-trænet model
• Finjuster den fortrænede model på et nyt brugerdefineret datasæt
• Forbedre finjusteringsydelsen yderligere med SageMaker automatisk model tuning
• Evaluer modellens ydeevne på de hold-out testdata med forskellige evalueringsmetrikker

Selvom vi dækker fem specifikke NLP-opgaver i dette indlæg, kan du bruge denne løsning som en skabelon til at generalisere finjustering af fortrænede modeller med dit eget datasæt og efterfølgende køre hyperparameteroptimering for at forbedre nøjagtigheden.

JumpStart løsningsskabeloner

Amazon SageMaker JumpStart leverer end-to-end-løsninger med ét klik til mange almindelige ML-brugssager. Udforsk følgende use cases for at få flere oplysninger om tilgængelige løsningsskabeloner:

JumpStart-løsningsskabelonerne dækker en række forskellige use cases, hvorunder hver af dem tilbydes flere forskellige løsningsskabeloner (denne Document Understanding-løsning er under "Udtræk og analyser data fra dokumenter" use case).

Vælg den løsningsskabelon, der passer bedst til din brugssituation, fra JumpStart-landingssiden. For mere information om specifikke løsninger under hver use case, og hvordan man starter en JumpStart-løsning, se Løsningsskabeloner.

Løsningsoversigt

Følgende billede viser, hvordan du kan bruge denne løsning med SageMaker-komponenter. SageMaker træningsjobs bruges til at træne de forskellige NLP-modeller, og SageMaker-endepunkter bruges til at implementere modellerne i hver fase. Vi bruger Amazon Simple Storage Service (Amazon S3) sammen med SageMaker for at gemme træningsdata og modelartefakter, og amazoncloudwatch at logge trænings- og slutpunktsoutput.

Åbn Document Understanding-løsningen

Naviger til Document Understanding-løsningen i JumpStart.

Nu kan vi se nærmere på nogle af de aktiver, der er inkluderet i denne løsning, begyndende med demo-notesbogen.

Demo notesbog

Du kan bruge demo-notesbogen til at sende eksempeldata til allerede implementerede modelslutpunkter til dokumentopsummering og besvarelse af spørgsmål. Demo-notebooken giver dig hurtigt mulighed for at få praktisk oplevelse ved at forespørge på eksempeldataene.

Når du har startet Document Understanding-løsningen, skal du åbne demo-notesbogen ved at vælge Brug Endpoint i Notebook.

Lad os dykke dybere ned i hver af de fem vigtigste notesbøger til denne løsning.

Forudsætninger

In Amazon SageMaker Studio, sørg for, at du bruger PyTorch 1.10 Python 3.8 CPU Optimized billede/kerne for at åbne notesbøgerne. Træning bruger fem ml.g4dn.2xlarge instanser, så du bør hæve en anmodning om øget servicegrænse hvis din konto kræver øgede grænser for denne type.

Tekstklassificering

Tekstklassificering refererer til klassificering af en inputsætning til en af ​​klasseetiketterne i træningsdatasættet. Denne notesbog viser, hvordan du bruger JumpStart API til tekstklassificering.

Implementer og kør inferens på den forudtrænede model

Den tekstklassificeringsmodel, vi har valgt at bruge, er bygget på en tekstindlejring (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) model fra TensorFlow Hub, som er fortrænet på Wikipedia og BookCorpus datasæt.

Den model, der er tilgængelig til implementering, oprettes ved at knytte et binært klassifikationslag til outputtet af tekstindlejringsmodellen og derefter finjustere hele modellen på SST-2 datasæt, som består af positive og negative filmanmeldelser.

For at køre inferens på denne model skal vi først downloade inferensbeholderen (deploy_image_uri), slutningsskrift (deploy_source_uri), og foruddannet model (base_model_uri). Vi sender dem derefter som parametre for at instantiere et SageMaker-modelobjekt, som vi derefter kan implementere:

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 "

Følgende kode viser vores svar:

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

Finjuster den fortrænede model på et brugerdefineret datasæt

Vi har lige gået gennem løbeslutning på en fortrænet BERT-model, som var finjusteret på SST-2 datasæt.

Dernæst diskuterer vi, hvordan man finjusterer en model på et brugerdefineret datasæt med et vilkårligt antal klasser. Datasættet, vi bruger til finjustering, er stadig SST-2 datasæt. Du kan erstatte dette datasæt med ethvert datasæt, som du er interesseret i.

Vi henter trænings Docker-containeren, træningsalgoritmekilden og den forudtrænede model:

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

For algoritmespecifikke hyperparametre starter vi med at hente en Python-ordbog over de træningshyperparametre, som algoritmen accepterer med deres standardværdier. Du kan tilsidesætte dem med brugerdefinerede værdier, som vist i følgende kode:

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"

Datasættet (SST-2) er opdelt i trænings-, validerings- og testsæt, hvor træningssættet bruges til at passe til modellen, valideringssættet bruges til at beregne evalueringsmetrikker, der kan bruges til HPO, og testsættet bruges som hold-out-data til evaluering af modellens ydeevne. Derefter uploades tog- og valideringsdatasættet til Amazon S3 og bruges til at starte finjusteringsopgaven:

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

Når finjusteringsopgaven er fuldført, implementerer vi modellen, kører inferens på hold-out-testdatasættet og beregner evalueringsmetrikker. Fordi det er en binær klassifikationsopgave, bruger vi nøjagtighedsscore , f1 score som evalueringsmetrikken. En større værdi indikerer den bedre ydeevne. Følgende skærmbillede viser vores resultater.

Forbedre finjusteringsydelsen yderligere med SageMaker automatisk modeljustering

I dette trin viser vi, hvordan du yderligere kan forbedre modellens ydeevne ved at finjustere modellen med SageMaker automatisk modeljustering. Automatisk modeljustering, også kendt som hyperparameteroptimering (HPO), finder den bedste version af en model ved at køre flere træningsjob på dit datasæt med en række hyperparametre, som du angiver. Den vælger derefter de hyperparameterværdier, der resulterer i en model, der yder bedst, målt med en metrik, som du vælger, på valideringsdatasættet.

Først sætter vi målet som nøjagtighedsscore på valideringsdataene (val_accuracy) og definerede metrics for tuning-jobbet ved at angive det objektive metriske navn og et regulært udtryk (regex). Det regulære udtryk bruges til at matche algoritmens logoutput og fange de numeriske værdier af metrikker. Dernæst specificerer vi hyperparameterområder for at vælge de bedste hyperparameterværdier fra. Vi sætter det samlede antal tuningjobs til seks og fordeler disse jobs på tre forskellige Amazon Elastic Compute Cloud (Amazon EC2) forekomster til at køre parallelle tuningjob. Se følgende kode:

# 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

Vi videregiver disse værdier for at instantiere et SageMaker Estimator-objekt, svarende til det, vi gjorde i det forrige finjusteringstrin. I stedet for at ringe til fit funktion af Estimator objekt, vi passerer Estimator objekt i som en parameter til HyperparameterTuner konstruktør og ring til fit funktion af det til at starte tuning job:

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

Når tuning-jobbene er fuldført, implementerer vi den model, der giver den bedste evaluerings-metriske score på valideringsdatasættet, udfører konklusioner på det samme hold-out-testdatasæt, som vi gjorde i det foregående afsnit, og beregner evalueringsmetrikker.

Resultaterne viser, at den model, der er valgt ved automatisk modeljustering, overgår den model, der blev finjusteret i det foregående afsnit på et hold-out-testdatasæt.

Navngivet enhedsgenkendelse

Navngivne entitetsgenkendelse (NER) er processen med at detektere og klassificere navngivne enheder i foruddefinerede kategorier, såsom navne på personer, organisationer, lokationer og mængder. Der er mange anvendelsessager i den virkelige verden for NER, såsom anbefalingsmotorer, kategorisering og tildeling af kundesupportbilletter til den rigtige afdeling, udtrækning af væsentlig information fra patientrapporter i sundhedsvæsenet og indholdsklassificering fra nyheder og blogs.

Implementer og kør inferens på den forudtrænede model

Vi implementerer En_core_web_md model fra spaCy bibliotek. spaCy er et open source NLP-bibliotek, der kan bruges til forskellige opgaver, og har indbyggede metoder til NER. Vi bruger en AWS PyTorch Deep Learning Container (DLC) med en script-tilstand og installerer spaCy-biblioteket som en afhængighed oven på containeren.

Dernæst et indgangspunkt for scriptet (argument entry_point.py) er specificeret og indeholder al koden til at downloade og indlæse En_core_web_md modellere og udføre inferens på de data, der sendes til endepunktet. Endelig mangler vi stadig at yde model_data som den fortrænede model for slutninger. Fordi de fortrænede En_core_web_md model downloades on the fly, som er specificeret i indtastningsscriptet, leverer vi en tom arkivfil. Når slutpunktet er implementeret, kan du kalde slutpunktet direkte fra notesbogen ved hjælp af SageMaker Python SDK'er Predictor. Se følgende kode:

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

Inputdata for modellen er et tekstdokument. Den navngivne enhedsmodel udtrækker navneordsstykker og navngivne enheder i tekstdokumentet og klassificerer dem i en række forskellige typer (såsom personer, steder og organisationer). Eksempel på input og output er vist i følgende kode. Det start_char parameter angiver tegnforskydningen for starten af ​​spændvidden, og end_char angiver slutningen af ​​spændvidden.

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

Finjuster den fortrænede model på et brugerdefineret datasæt

I dette trin demonstrerer vi, hvordan man finjusterer en fortrænet sprogmodel til NER på dit eget datasæt. Finjusteringstrinnet opdaterer modelparametrene for at fange karakteristikken af ​​dine egne data og forbedre nøjagtigheden. Vi bruger WikiANN (PAN-X) datasæt til at finjustere DistilBERT-base-ukappet Transformer model fra Hugging Face.

Datasættet er opdelt i trænings-, validerings- og testsæt.

Dernæst specificerer vi modellens hyperparametre og bruger en AWS Hugging Face DLC med en script-tilstand (argument entry_point) for at udløse finjusteringsjobbet:

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
)

Når finjusteringsopgaven er fuldført, implementerer vi et slutpunkt og forespørger på dette slutpunkt med de tilbageholdte testdata. For at forespørge på slutpunktet skal hver tekststreng tokeniseres til en eller flere tokens og sendes til transformatormodellen. Hvert token får et forudsagt navngivet entity tag. Fordi hver tekststreng kan tokeniseres til en eller flere tokens, er vi nødt til at duplikere grundsandhedens navngivne entity-tag for strengen til alle de tokens, der er knyttet til den. Den medfølgende notesbog fører dig gennem trinene for at opnå dette.

Til sidst bruger vi Hugging Face indbyggede evalueringsmetrics seqeval til at beregne evalueringsresultater på de hold-out testdata. De anvendte evalueringsmetrikker er generel præcision, generel genkaldelse, samlet F1 og nøjagtighed. Følgende skærmbillede viser vores resultater.

Forbedre finjusteringsydelsen yderligere med SageMaker automatisk modeljustering

I lighed med tekstklassificering demonstrerer vi, hvordan du yderligere kan forbedre modellens ydeevne ved at finjustere modellen med SageMaker automatisk modeljustering. For at køre tuning-jobbet skal vi definere en objektiv metrik, vi vil bruge til at evaluere modelydelse på valideringsdatasættet (F1-score i dette tilfælde), hyperparameterområder til at vælge de bedste hyperparameterværdier fra, samt tuning af jobkonfigurationer som f.eks. maksimalt antal tuningjob og antal parallelle job, der skal startes ad gangen:

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)

Når tuning-jobbene er fuldført, implementerer vi den model, der giver den bedste evaluerings-metriske score på valideringsdatasættet, udfører konklusioner på det samme hold-out-testdatasæt, som vi gjorde i det foregående afsnit, og beregner evalueringsmetrikker.

Vi kan se, at modellen med HPO opnår markant bedre ydeevne på tværs af alle målinger.

Besvarelse af spørgsmål

Besvarelse af spørgsmål er nyttig, når du vil forespørge på en stor mængde tekst for at få specifikke oplysninger. Det giver en bruger mulighed for at udtrykke et spørgsmål i naturligt sprog og få et øjeblikkeligt og kort svar. Spørgsmålsbesvarelsessystemer drevet af NLP kan bruges i søgemaskiner og telefonsamtalegrænseflader.

Implementer og kør inferens på den forudtrænede model

Vores præ-trænede model er den ekstraktive spørgsmål besvarelse (EQA) model bert-store-uindkapslede-hel-ord-maskering-finjusteret-squad bygget på en Transformer-model fra Hugging Face. Vi bruger en AWS PyTorch DLC med en script-tilstand og installerer transformers bibliotek som en afhængighed oven på containeren. I lighed med NER-opgaven giver vi en tom arkivfil i argumentet model_data fordi den fortrænede model downloades i farten. Når slutpunktet er implementeret, kan du kalde slutpunktet direkte fra notesbogen ved hjælp af SageMaker Python SDK'er Predictor. Se følgende kode:

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

Det eneste, vi skal gøre, er at konstruere et ordbogsobjekt med to nøgler. context er den tekst, vi ønsker at hente information fra. question er den naturlige sprogforespørgsel, der specificerer, hvilken information vi er interesseret i at udtrække. Vi ringer predict på vores prædiktor, og vi bør få et svar fra det endepunkt, der indeholder de mest sandsynlige svar:

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

Vi har svaret, og vi kan udskrive de mest sandsynlige svar, der er udtrukket fra den foregående tekst. Hvert svar har en tillidsscore, der bruges til rangering (men denne score skal ikke tolkes som en sand sandsynlighed). Ud over det ordrette svar får du også start- og slutkarakterindeksene for svaret fra den oprindelige kontekst:

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

Nu finjusterer vi denne model med vores eget tilpassede datasæt for at få bedre resultater.

Finjuster den fortrænede model på et brugerdefineret datasæt

I dette trin demonstrerer vi, hvordan du finjusterer en fortrænet sprogmodel til EQA på dit eget datasæt. Finjusteringstrinnet opdaterer modelparametrene for at fange karakteristikken af ​​dine egne data og forbedre nøjagtigheden. Vi bruger SQuAD2.0 datasæt til at finjustere en tekstindlejringsmodel bert-base-ukappet fra Hugging Face. Den tilgængelige model til finjustering knytter et svarudtrækslag til tekstindlejringsmodellen og initialiserer lagparametrene til tilfældige værdier. Finjusteringstrinnet finjusterer alle modelparametre for at minimere forudsigelsesfejl på inputdata og returnerer den finjusterede model.

I lighed med tekstklassificeringsopgaven er datasættet (SQuAD2.0) opdelt i træning, validering og testsæt.

Dernæst specificerer vi modellens hyperparametre og bruger JumpStart API for at udløse et finjusteringsjob:

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)

Når finjusteringsopgaven er fuldført, implementerer vi modellen, kører inferens på hold-out-testdatasættet og beregner evalueringsmetrikker. De anvendte evalueringsmålinger er den gennemsnitlige score for nøjagtig matchning og den gennemsnitlige F1-score. Følgende skærmbillede viser resultaterne.

Forbedre finjusteringsydelsen yderligere med SageMaker automatisk modeljustering

I lighed med de foregående afsnit bruger vi en HyperparameterTuner gør indsigelse mod at starte tuningjob:

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

Når tuning-jobbene er fuldført, implementerer vi den model, der giver den bedste evaluerings-metriske score på valideringsdatasættet, udfører konklusioner på det samme hold-out-testdatasæt, som vi gjorde i det foregående afsnit, og beregner evalueringsmetrikker.

Vi kan se, at modellen med HPO viser en markant bedre ydeevne på hold-out testdata.

Relationsudvinding

Relationsekstraktion er opgaven med at udtrække semantiske relationer fra tekst, som normalt forekommer mellem to eller flere entiteter. Relationsekstraktion spiller en vigtig rolle i at udtrække struktureret information fra ustrukturerede kilder såsom rå tekst. I denne notesbog demonstrerer vi to eksempler på brug af relationsekstraktion.

Finjuster den fortrænede model på et brugerdefineret datasæt

Vi bruger en relationsekstraktionsmodel bygget på en BERT-base-ukappet model ved hjælp af transformere fra Hugging Face transformere bibliotek. Modellen til finjustering vedhæfter et lineært klassifikationslag, der tager et par token-indlejringer, som udlæses af tekstindlejringsmodellen, og initialiserer lagparametrene til tilfældige værdier. Finjusteringstrinnet finjusterer alle modelparametre for at minimere forudsigelsesfejl på inputdata og returnerer den finjusterede model.

Det datasæt vi finjusterer modellen er SemEval-2010 Opgave 8. Den model, der returneres ved finjustering, kan videreudvikles til slutninger.

Datasættet indeholder trænings-, validerings- og testsæt.

Vi bruger AWS PyTorch DLC med en script-tilstand fra SageMaker Python SDK, hvor transformers bibliotek er installeret som afhængigheden oven på containeren. Vi definerer SageMaker PyTorch estimator og et sæt hyperparametre såsom den forudtrænede model, indlæringshastighed og epoketal for at udføre finjusteringen. Koden til finjustering af relationsekstraktionsmodellen er defineret i entry_point.py. Se følgende kode:

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

Forbedre finjusteringsydelsen yderligere med SageMaker automatisk modeljustering

I lighed med de foregående afsnit bruger vi en HyperparameterTuner objekt til at interagere med SageMaker hyperparameter tuning API'er. Vi kan starte hyperparameterindstillingsjobbet ved at kalde fit metode:

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

Når hyperparameterindstillingsjobbet er afsluttet, udfører vi slutninger og kontrollerer evalueringsresultatet.

Vi kan se, at modellen med HPO viser bedre ydeevne på hold-out testdata.

Dokumentopsummering

Dokument- eller tekstresumé er opgaven med at kondensere store mængder tekstdata til en mindre delmængde af meningsfulde sætninger, der repræsenterer den vigtigste eller mest relevante information i det originale indhold. Dokumentresumé er en nyttig teknik til at destillere vigtig information fra store mængder tekstdata til nogle få sætninger. Tekstopsummering bruges i mange use cases, såsom dokumentbehandling og udtrækning af information fra blogs, artikler og nyheder.

Denne notesbog demonstrerer implementeringen af ​​dokumentopsummeringsmodellen T5-base fra Hugging Face transformere bibliotek. Vi tester også de implementerede endepunkter ved hjælp af en tekstartikel og evaluerer resultater ved hjælp af den indbyggede Hugging Face-evalueringsmetrik RED.

I lighed med spørgsmålsbesvarelsen og NER-notesbøgerne bruger vi PyTorchModel fra SageMaker Python SDK sammen med en entry_point.py script til at indlæse T5-basemodellen til et HTTPS-slutpunkt. Når slutpunktet er implementeret, kan vi sende en tekstartikel til slutpunktet for at få et forudsigelsessvar:

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

Dernæst evaluerer og sammenligner vi tekstartiklen og opsummeringsresultatet ved hjælp af ROUGE-metrikken. Der beregnes tre evalueringsmetrics: rougeN, rougeLog rougeLsum. rougeN måler antallet af matchende n-grams mellem den modelgenererede tekst (resuméresultat) og en reference (input tekst). Metrikken rougeL , rougeLsum mål de længste matchende sekvenser af ord ved at lede efter de længste fælles understrenge i de genererede resuméer og referenceresuméer. For hver metrik beregnes konfidensintervaller for præcision, genkaldelse og F1-score. Se følgende kode:

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

Ryd op

Ressourcer oprettet til denne løsning kan slettes ved hjælp af Slet alle ressourcer knap fra SageMaker Studio IDE. Hver notesbog indeholder også en oprydningssektion med koden til at slette slutpunkterne.

Konklusion

I dette indlæg demonstrerede vi, hvordan man bruger state-of-the-art ML-teknikker til at løse fem forskellige NLP-opgaver: dokumentopsummering, tekstklassificering, spørgsmål og svar, navngivet enhedsgenkendelse og relationsudtrækning ved hjælp af Jumpstart. Kom godt i gang med Jumpstart nu!

Om forfatterne

Dr. Xin Huang er en Applied Scientist for Amazon SageMaker JumpStart og Amazon SageMaker indbyggede algoritmer. Han fokuserer på at udvikle skalerbare maskinlæringsalgoritmer. Hans forskningsinteresser er inden for området naturlig sprogbehandling, forklarlig dyb læring på tabeldata og robust analyse af ikke-parametrisk rum-tid-klynger. Han har publiceret mange artikler i ACL, ICDM, KDD-konferencer og Royal Statistical Society: Series A journal.

Vivek Gangasani er Senior Machine Learning Solutions Architect hos Amazon Web Services. Han hjælper startups med at bygge og operationalisere AI/ML-applikationer. Han er i øjeblikket fokuseret på at kombinere sin baggrund inden for containere og maskinlæring for at levere løsninger på MLOps, ML Inference og low-code ML. I sin fritid nyder han at prøve nye restauranter og udforske nye tendenser inden for kunstig intelligens og dyb læring.

Geremy Cohen er Solutions Architect hos AWS, hvor han hjælper kunder med at bygge banebrydende, cloud-baserede løsninger. I sin fritid nyder han korte gåture på stranden, udforske bugten med sin familie, ordne ting omkring huset, bryde ting rundt i huset og grille.

Neelam Koshiya er virksomhedsløsningsarkitekt hos AWS. Hendes nuværende fokus er at hjælpe virksomhedskunder med deres cloud-adoptionsrejse for strategiske forretningsresultater. I sin fritid nyder hun at læse og være udendørs.