Identifiser nøkkelinnsikt fra tekstdokumenter gjennom finjustering og HPO med Amazon SageMaker JumpStart

Organisasjoner på tvers av bransjer som detaljhandel, bank, finans, helsevesen, produksjon og utlån må ofte håndtere enorme mengder ustrukturerte tekstdokumenter som kommer fra ulike kilder, som nyheter, blogger, produktanmeldelser, kundestøttekanaler og sosiale medier. Disse dokumentene inneholder viktig informasjon som er nøkkelen til å ta viktige forretningsbeslutninger. Etter hvert som en organisasjon vokser, blir det en utfordring å trekke ut kritisk informasjon fra disse dokumentene. Med utviklingen av naturlig språkbehandling (NLP) og maskinlæring (ML)-teknikker, kan vi avdekke verdifull innsikt og sammenhenger fra disse tekstdokumentene raskt og med høy nøyaktighet, og dermed hjelpe bedrifter med å ta kvalitetsbeslutninger i tide. Fullt administrerte NLP-tjenester har også fremskyndet innføringen av NLP. Amazon Comprehend er en fullstendig administrert tjeneste som lar deg bygge tilpassede NLP-modeller som er spesifikke for dine behov, uten behov for ML-ekspertise.

I dette innlegget demonstrerer vi hvordan du kan bruke state-of-the-art ML-teknikker for å løse fem forskjellige NLP-oppgaver: dokumentoppsummering, tekstklassifisering, spørsmålssvar, navngitt enhetsgjenkjenning og relasjonsutvinning. For hver av disse NLP-oppgavene viser vi hvordan du bruker Amazon SageMaker for å utføre følgende handlinger:

• Distribuer og kjør inferens på en forhåndstrent modell
• Finjuster den forhåndstrente modellen på et nytt tilpasset datasett
• Forbedre finjusteringsytelsen ytterligere med SageMaker automatisk modellinnstilling
• Evaluer modellens ytelse på hold-out-testdataene med ulike evalueringsverdier

Selv om vi dekker fem spesifikke NLP-oppgaver i dette innlegget, kan du bruke denne løsningen som en mal for å generalisere finjustering av forhåndstrente modeller med ditt eget datasett, og deretter kjøre hyperparameteroptimalisering for å forbedre nøyaktigheten.

JumpStart løsningsmaler

Amazon SageMaker JumpStart gir ett-klikks, ende-til-ende-løsninger for mange vanlige ML-brukstilfeller. Utforsk følgende brukstilfeller for mer informasjon om tilgjengelige løsningsmaler:

JumpStart-løsningsmalene dekker en rekke brukstilfeller, under hver av disse tilbys flere forskjellige løsningsmaler (denne Document Understanding-løsningen er under brukstilfellet "Trekk ut og analyser data fra dokumenter").

Velg løsningsmalen som passer best for din brukssituasjon fra JumpStart-landingssiden. For mer informasjon om spesifikke løsninger under hvert brukstilfelle og hvordan du starter en JumpStart-løsning, se Løsningsmaler.

Løsningsoversikt

Følgende bilde viser hvordan du kan bruke denne løsningen med SageMaker-komponenter. SageMaker-opplæringsjobbene brukes til å trene de ulike NLP-modellene, og SageMaker-endepunkter brukes til å distribuere modellene i hvert trinn. Vi bruker Amazon enkel lagringstjeneste (Amazon S3) sammen med SageMaker for å lagre treningsdata og modellartefakter, og Amazon CloudWatch for å logge trening og endepunktutganger.

Åpne Document Understanding-løsningen

Naviger til Document Understanding-løsningen i JumpStart.

Nå kan vi se nærmere på noen av eiendelene som er inkludert i denne løsningen, og starter med demo-notatboken.

Demo notatbok

Du kan bruke demo-notatboken til å sende eksempeldata til allerede distribuerte modellendepunkter for dokumentoppsummering og spørsmålssvarsoppgaver. Demo-notatboken lar deg raskt få praktisk erfaring ved å spørre etter eksempeldata.

Etter at du har startet Document Understanding-løsningen, åpner du demo-notatboken ved å velge Bruk endepunkt i Notebook.

La oss dykke dypere inn i hver av de fem hovednotatbøkene for denne løsningen.

Forutsetninger

In Amazon SageMaker Studio, sørg for at du bruker PyTorch 1.10 Python 3.8 CPU Optimized bilde/kjerne for å åpne notatbøkene. Trening bruker fem ml.g4dn.2xlarge forekomster, så du bør heve en forespørsel om økt tjenestegrense hvis kontoen din krever økte grenser for denne typen.

Tekst klassifisering

Tekstklassifisering refererer til å klassifisere en inngangssetning til en av klasseetikettene til opplæringsdatasettet. Denne notatboken viser hvordan du bruker JumpStart API for tekstklassifisering.

Distribuer og kjør inferens på den forhåndstrente modellen

Tekstklassifiseringsmodellen vi har valgt å bruke er bygget på en tekstinnbygging (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) modell fra TensorFlow Hub, som er forhåndsopplært på Wikipedia og BookCorpus datasett.

Modellen som er tilgjengelig for distribusjon lages ved å feste et binært klassifiseringslag til utdataene fra tekstinnbyggingsmodellen, og deretter finjustere hele modellen på SST-2 datasett, som består av positive og negative filmanmeldelser.

For å kjøre inferens på denne modellen, må vi først laste ned inferensbeholderen (deploy_image_uri), slutningsskrift (deploy_source_uri), og forhåndstrent modell (base_model_uri). Vi sender deretter disse som parametere for å instansiere et SageMaker-modellobjekt, som vi deretter kan distribuere:

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 våre 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 forhåndstrente modellen på et tilpasset datasett

Vi gikk nettopp gjennom løpende inferens på en forhåndstrent BERT-modell, som var finjustert på SST-2 datasett.

Deretter diskuterer vi hvordan du finjusterer en modell på et tilpasset datasett med et hvilket som helst antall klasser. Datasettet vi bruker for finjustering er fortsatt SST-2 datasett. Du kan erstatte dette datasettet med et hvilket som helst datasett du er interessert i.

Vi henter opplærings Docker-beholderen, opplæringsalgoritmekilden og forhåndstrente modellen:

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 algoritmespesifikke hyperparametre starter vi med å hente en Python-ordbok over treningshyperparametrene som algoritmen aksepterer med standardverdiene. Du kan overstyre dem med egendefinerte verdier, 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"

Datasettet (SST-2) er delt inn i trenings-, validerings- og testsett, der treningssettet brukes for å passe modellen, valideringssettet brukes til å beregne evalueringsmetrikker som kan brukes for HPO, og testsettet brukes som hold-out-data for å evaluere modellens ytelse. Deretter lastes tog- og valideringsdatasettet opp til Amazon S3 og brukes til å starte finjusteringsopplæringsjobben:

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

Etter at finjusteringsjobben er fullført, distribuerer vi modellen, kjører inferens på hold-out-testdatasettet og beregner evalueringsverdier. Fordi det er en binær klassifiseringsoppgave, bruker vi nøyaktighetspoeng og F1-poengsum som evalueringsmålene. En større verdi indikerer bedre ytelse. Følgende skjermbilde viser resultatene våre.

Forbedre finjusteringsytelsen ytterligere med SageMaker automatisk modellinnstilling

I dette trinnet viser vi hvordan du kan forbedre modellytelsen ytterligere ved å finjustere modellen med SageMaker automatisk modellinnstilling. Automatisk modellinnstilling, også kjent som hyperparameteroptimalisering (HPO), finner den beste versjonen av en modell ved å kjøre flere treningsjobber på datasettet med en rekke hyperparametre som du spesifiserer. Den velger deretter hyperparameterverdiene som resulterer i en modell som gir best ytelse, målt med en beregning du velger, på valideringsdatasettet.

Først setter vi målet som nøyaktighetsscore på valideringsdataene (val_accuracy) og definerte beregninger for innstillingsjobben ved å spesifisere det objektive metriske navnet og et regulært uttrykk (regex). Det regulære uttrykket brukes til å matche algoritmens loggutdata og fange opp de numeriske verdiene til metrikkene. Deretter spesifiserer vi hyperparameterområder for å velge de beste hyperparameterverdiene fra. Vi setter totalt antall tuningjobber til seks og fordeler disse jobbene på tre forskjellige Amazon Elastic Compute Cloud (Amazon EC2) forekomster for å kjøre parallelle innstillingsjobber. 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 sender disse verdiene for å instansiere et SageMaker Estimator-objekt, som ligner på det vi gjorde i forrige finjusteringstrinn. I stedet for å ringe fit funksjon av Estimator objekt, passerer vi Estimator objekt inn som en parameter til HyperparameterTuner konstruktør og ring fit funksjon for å starte tuningjobber:

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

Etter at innstillingsjobbene er fullført, implementerer vi modellen som gir den beste evalueringsmetriske poengsummen på valideringsdatasettet, utfører slutninger på det samme hold-out-testdatasettet som vi gjorde i forrige seksjon, og beregner evalueringsberegninger.

Resultatene viser at modellen valgt ved automatisk modellinnstilling overgår den modellen finjustert i forrige avsnitt på et hold-out-testdatasett.

Navngitt enhetsgjenkjenning

Navngitt enhetsgjenkjenning (NER) er prosessen med å oppdage og klassifisere navngitte enheter i forhåndsdefinerte kategorier, for eksempel navn på personer, organisasjoner, lokasjoner og mengder. Det er mange virkelige brukstilfeller for NER, for eksempel anbefalingsmotorer, kategorisering og tildeling av kundestøttebilletter til riktig avdeling, uttrekk av viktig informasjon fra pasientrapporter i helsevesenet og innholdsklassifisering fra nyheter og blogger.

Distribuer og kjør inferens på den forhåndstrente modellen

Vi distribuerer En_core_web_md modell fra spaCy bibliotek. spaCy er et åpen kildekode NLP-bibliotek som kan brukes til ulike oppgaver, og har innebygde metoder for NER. Vi bruker en AWS PyTorch Deep Learning Container (DLC) med en skriptmodus og installerer spaCy-biblioteket som en avhengighet på toppen av containeren.

Deretter et inngangspunkt for skriptet (argument entry_point.py) er spesifisert, og inneholder all koden for å laste ned og laste En_core_web_md modellere og utføre inferens på dataene som sendes til endepunktet. Til slutt må vi fortsatt gi model_data som den forhåndstrente modellen for slutninger. Fordi de forhåndstrente En_core_web_md modellen lastes ned på fly, som er spesifisert i oppføringsskriptet, gir vi en tom arkivfil. Etter at endepunktet er distribuert, kan du påkalle endepunktet direkte fra notatboken ved å bruke SageMaker Python SDK-ene 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()
)

Inndataene for modellen er et tekstdokument. Den navngitte enhetsmodellen trekker ut substantivbiter og navngitte enheter i tekstdokumentet og klassifiserer dem i en rekke forskjellige typer (som personer, steder og organisasjoner). Eksempelinngang og utgang vises i følgende kode. De start_char parameter indikerer tegnforskyvningen for starten av spennet, og end_char indikerer slutten av spennet.

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 forhåndstrente modellen på et tilpasset datasett

I dette trinnet viser vi hvordan du finjusterer en forhåndstrent språkmodell for NER på ditt eget datasett. Finjusteringstrinnet oppdaterer modellparametrene for å fange opp egenskapene til dine egne data og forbedre nøyaktigheten. Vi bruker WikiANN (PAN-X) datasett for å finjustere DistilBERT-base-ukappet Transformatormodell fra Hugging Face.

Datasettet er delt inn i trenings-, validerings- og testsett.

Deretter spesifiserer vi hyperparametrene til modellen, og bruker en AWS Hugging Face DLC med en skriptmodus (argument entry_point) for å utløse finjusteringsjobben:

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
)

Etter at finjusteringsjobben er fullført, distribuerer vi et endepunkt og spør etter det endepunktet med hold-out-testdataene. For å spørre etter endepunktet, må hver tekststreng tokeniseres til ett eller flere tokens og sendes til transformatormodellen. Hvert token får en forutsagt navngitt enhetskode. Fordi hver tekststreng kan tokeniseres til ett eller flere tokens, må vi duplisere grunnsannhetens navngitte entity-tag for strengen til alle tokens som er knyttet til den. Den medfølgende notatboken leder deg gjennom trinnene for å oppnå dette.

Til slutt bruker vi Hugging Face innebygde evalueringsmålinger etterfølgende å beregne evalueringsresultater på hold-out testdata. Evalueringsberegningene som brukes er generell presisjon, generell tilbakekalling, generell F1 og nøyaktighet. Følgende skjermbilde viser resultatene våre.

Forbedre finjusteringsytelsen ytterligere med SageMaker automatisk modellinnstilling

I likhet med tekstklassifisering viser vi hvordan du kan forbedre modellytelsen ytterligere ved å finjustere modellen med SageMaker automatisk modellinnstilling. For å kjøre tuning-jobben, må vi definere en objektiv beregning vi vil bruke for å evaluere modellytelse på valideringsdatasettet (F1-poengsum i dette tilfellet), hyperparameterområder for å velge de beste hyperparameterverdiene fra, samt tuning av jobbkonfigurasjoner som f.eks. maksimalt antall tuningjobber og antall parallelle jobber som skal lanseres om 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)

Etter at innstillingsjobbene er fullført, implementerer vi modellen som gir den beste evalueringsmetriske poengsummen på valideringsdatasettet, utfører slutninger på det samme hold-out-testdatasettet som vi gjorde i forrige seksjon, og beregner evalueringsberegninger.

Vi kan se at modellen med HPO oppnår betydelig bedre ytelse på tvers av alle beregninger.

Svar på spørsmål

Svar på spørsmål er nyttig når du ønsker å spørre om en stor mengde tekst for spesifikk informasjon. Den lar en bruker uttrykke et spørsmål på naturlig språk og få et umiddelbart og kort svar. Spørsmålssvarssystemer drevet av NLP kan brukes i søkemotorer og telefonsamtalegrensesnitt.

Distribuer og kjør inferens på den forhåndstrente modellen

Vår ferdigtrente modell er modellen for å svare på ekstraktive spørsmål (EQA). bert-large-uhus-hel-ord-maskering-finjustert-troppen bygget på en Transformer-modell fra Hugging Face. Vi bruker en AWS PyTorch DLC med en skriptmodus og installerer transformers bibliotek som en avhengighet på toppen av beholderen. I likhet med NER-oppgaven gir vi en tom arkivfil i argumentet model_data fordi den ferdigtrente modellen lastes ned i farten. Etter at endepunktet er distribuert, kan du påkalle endepunktet direkte fra notatboken ved å bruke SageMaker Python SDK-ene 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",
    },
)

Alt vi trenger å gjøre er å konstruere et ordbokobjekt med to nøkler. context er teksten vi ønsker å hente informasjon fra. question er det naturlige språkspørsmålet som spesifiserer hvilken informasjon vi er interessert i å trekke ut. Vi ringer predict på prediktoren vår, og vi bør få et svar fra endepunktet som inneholder de mest sannsynlige svarene:

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

Vi har svaret, og vi kan skrive ut de mest sannsynlige svarene som er hentet fra den foregående teksten. Hvert svar har en konfidenspoengsum som brukes for rangering (men denne poengsummen skal ikke tolkes som en sann sannsynlighet). I tillegg til det ordrette svaret, får du også start- og slutttegnindeksene til svaret fra den opprinnelige konteksten:

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

Nå finjusterer vi denne modellen med vårt eget tilpassede datasett for å få bedre resultater.

Finjuster den forhåndstrente modellen på et tilpasset datasett

I dette trinnet viser vi hvordan du finjusterer en forhåndstrent språkmodell for EQA på ditt eget datasett. Finjusteringstrinnet oppdaterer modellparametrene for å fange opp egenskapene til dine egne data og forbedre nøyaktigheten. Vi bruker SQuAD2.0 datasett for å finjustere en tekstinnbyggingsmodell bert-base-uncased fra Hugging Face. Modellen som er tilgjengelig for finjustering, knytter et svaruttrekkslag til tekstinnbyggingsmodellen og initialiserer lagparametrene til tilfeldige verdier. Finjusteringstrinnet finjusterer alle modellparametrene for å minimere prediksjonsfeil på inngangsdataene og returnerer den finjusterte modellen.

I likhet med tekstklassifiseringsoppgaven er datasettet (SQuAD2.0) delt inn i trening, validering og testsett.

Deretter spesifiserer vi hyperparametrene til modellen, og bruker JumpStart API for å utløse en finjusteringsjobb:

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)

Etter at finjusteringsjobben er fullført, distribuerer vi modellen, kjører inferens på hold-out-testdatasettet og beregner evalueringsverdier. Evalueringsberegningene som brukes er gjennomsnittlig nøyaktig samsvarende poengsum og gjennomsnittlig F1-poengsum. Følgende skjermbilde viser resultatene.

Forbedre finjusteringsytelsen ytterligere med SageMaker automatisk modellinnstilling

I likhet med de forrige avsnittene bruker vi en HyperparameterTuner protesterer mot å starte tuningjobber:

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

Etter at innstillingsjobbene er fullført, implementerer vi modellen som gir den beste evalueringsmetriske poengsummen på valideringsdatasettet, utfører slutninger på det samme hold-out-testdatasettet som vi gjorde i forrige seksjon, og beregner evalueringsberegninger.

Vi kan se at modellen med HPO viser en betydelig bedre ytelse på hold-out-testdataene.

Relasjonsutvinning

Relasjonsekstraksjon er oppgaven med å trekke ut semantiske relasjoner fra tekst, som vanligvis forekommer mellom to eller flere enheter. Relasjonsutvinning spiller en viktig rolle i å trekke ut strukturert informasjon fra ustrukturerte kilder som råtekst. I denne notatboken viser vi to brukstilfeller av relasjonsutvinning.

Finjuster den forhåndstrente modellen på et tilpasset datasett

Vi bruker en relasjonsekstraksjonsmodell bygget på en BERT-base-ukappet modell ved hjelp av transformatorer fra Hugging Face transformatorer bibliotek. Modellen for finjustering legger til et lineært klassifiseringslag som tar et par token-innbygginger som sendes ut av tekstinnbyggingsmodellen og initialiserer lagparametrene til tilfeldige verdier. Finjusteringstrinnet finjusterer alle modellparametrene for å minimere prediksjonsfeil på inngangsdataene og returnerer den finjusterte modellen.

Datasettet vi finjusterer modellen er SemEval-2010 Oppgave 8. Modellen som returneres ved finjustering kan distribueres videre for slutninger.

Datasettet inneholder opplæring, validering og testsett.

Vi bruker AWS PyTorch DLC med en skriptmodus fra SageMaker Python SDK, der transformers biblioteket er installert som avhengighet på toppen av beholderen. Vi definerer SageMaker PyTorch estimator og et sett med hyperparametre som den forhåndstrente modellen, læringshastighet og epoketall for å utføre finjusteringen. Koden for finjustering av relasjonsekstraksjonsmodellen er definert 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 finjusteringsytelsen ytterligere med SageMaker automatisk modellinnstilling

I likhet med de forrige avsnittene bruker vi en HyperparameterTuner objekt for å samhandle med SageMaker hyperparameter tuning APIer. Vi kan starte hyperparameterinnstillingsjobben ved å ringe 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 hyperparameterinnstillingsjobben er fullført, utfører vi inferens og sjekker evalueringsresultatet.

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

Dokumentoppsummering

Dokument- eller tekstsammendrag er oppgaven med å kondensere store mengder tekstdata til en mindre delmengde av meningsfulle setninger som representerer den viktigste eller mest relevante informasjonen i det originale innholdet. Dokumentoppsummering er en nyttig teknikk for å destillere viktig informasjon fra store mengder tekstdata til noen få setninger. Tekstoppsummering brukes i mange brukstilfeller, for eksempel dokumentbehandling og uttrekking av informasjon fra blogger, artikler og nyheter.

Denne notatboken demonstrerer distribusjon av dokumentoppsummeringsmodellen T5-base fra Hugging Face transformatorer bibliotek. Vi tester også de utplasserte endepunktene ved hjelp av en tekstartikkel og evaluerer resultatene ved å bruke den innebygde evalueringsmetrikken for Hugging Face RED.

I likhet med spørsmålssvar og NER-notatbøker, bruker vi PyTorchModel fra SageMaker Python SDK sammen med en entry_point.py skript for å laste T5-basemodellen til et HTTPS-endepunkt. Etter at endepunktet er implementert, kan vi sende en tekstartikkel til endepunktet for å få et prediksjonssvar:

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

Deretter evaluerer og sammenligner vi tekstartikkelen og oppsummeringsresultatet ved å bruke ROUGE-beregningen. Tre evalueringsberegninger er beregnet: rougeN, rougeLog rougeLsum. rougeN måler antall matchende n-grams mellom den modellgenererte teksten (oppsummeringsresultat) og en reference (skriv inn tekst). Beregningene rougeL og rougeLsum mål de lengste samsvarende sekvensene av ord ved å se etter de lengste felles understrengene i de genererte sammendragene og referansesammendragene. For hver beregning beregnes konfidensintervaller for presisjon, tilbakekalling og F1-poengsum. 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))

Rydd opp

Ressurser opprettet for denne løsningen kan slettes ved å bruke Slett alle ressurser knappen fra SageMaker Studio IDE. Hver notatbok inneholder også en oppryddingsseksjon med koden for å slette endepunktene.

konklusjonen

I dette innlegget demonstrerte vi hvordan du kan bruke toppmoderne ML-teknikker for å løse fem forskjellige NLP-oppgaver: dokumentoppsummering, tekstklassifisering, spørsmål og svar, navngitt enhetsgjenkjenning og relasjonsutvinning ved hjelp av Jumpstart. Kom i gang med Jumpstart nå!

Om forfatterne

Dr. Xin Huang er en Applied Scientist for Amazon SageMaker JumpStart og Amazon SageMaker innebygde algoritmer. Han fokuserer på å utvikle skalerbare maskinlæringsalgoritmer. Hans forskningsinteresser er innen naturlig språkbehandling, forklarbar dyp læring på tabelldata og robust analyse av ikke-parametrisk rom-tid-klynger. Han har publisert mange artikler i ACL, ICDM, KDD-konferanser og Royal Statistical Society: Series A journal.

Vivek Gangasani er Senior Machine Learning Solutions Architect hos Amazon Web Services. Han hjelper startups med å bygge og operasjonalisere AI/ML-applikasjoner. Han er for tiden fokusert på å kombinere sin bakgrunn innen containere og maskinlæring for å levere løsninger på MLOps, ML Inference og lavkode ML. På fritiden liker han å prøve nye restauranter og utforske nye trender innen AI og dyp læring.

Geremy Cohen er løsningsarkitekt med AWS hvor han hjelper kunder med å bygge banebrytende, skybaserte løsninger. På fritiden liker han korte turer på stranden, utforske buktområdet med familien, fikse ting rundt huset, bryte ting rundt huset og grille.

Neelam Koshiya er en bedriftsløsningsarkitekt hos AWS. Hennes nåværende fokus er å hjelpe bedriftskunder med deres sky-adopsjon for strategiske forretningsresultater. På fritiden liker hun å lese og være utendørs.