Tuvastage tekstidokumentidest peamised arusaamad peenhäälestuse ja HPO abil Amazon SageMaker JumpStartiga

Organisatsioonid erinevates tööstusharudes, nagu jaekaubandus, pangandus, rahandus, tervishoid, tootmine ja laenuandmine, peavad sageli tegelema suure hulga struktureerimata tekstidokumentidega, mis pärinevad erinevatest allikatest, nagu uudised, ajaveebid, tootearvustused, klienditoe kanalid ja sotsiaalmeedia. Need dokumendid sisaldavad olulist teavet, mis on oluliste äriotsuste tegemisel võtmetähtsusega. Organisatsiooni kasvades muutub nendest dokumentidest kriitilise teabe ammutamine väljakutseks. Loodusliku keele töötlemise (NLP) ja masinõppe (ML) tehnikate edenemisega saame nendest tekstidokumentidest kiiresti ja suure täpsusega avastada väärtuslikke teadmisi ja seoseid, aidates seeläbi ettevõtetel õigeaegselt kvaliteetseid äriotsuseid langetada. Täielikult hallatavad NLP-teenused on samuti kiirendanud NLP kasutuselevõttu. Amazoni mõistmine on täielikult hallatav teenus, mis võimaldab teil luua kohandatud NLP-mudeleid, mis vastavad teie vajadustele, ilma et oleks vaja ML-teadmisi.

Selles postituses näitame, kuidas kasutada tipptasemel ML-tehnikaid viie erineva NLP-ülesande lahendamiseks: dokumentide kokkuvõte, teksti klassifitseerimine, küsimustele vastamine, nimega olemi tuvastamine ja suhete eraldamine. Iga sellise NLP-ülesande puhul näitame, kuidas seda kasutada Amazon SageMaker järgmiste toimingute tegemiseks:

• Juurutage ja käivitage järeldused eelkoolitatud mudelil
• Viimistlege eelkoolitatud mudelit uuel kohandatud andmekogumil
• Täiustage peenhäälestuse jõudlust veelgi SageMaker automaatne mudeli häälestamine
• Hinnake mudeli toimivust kinnipidamise katseandmete põhjal erinevate hindamismõõdikute abil

Kuigi käsitleme selles postituses viit konkreetset NLP-ülesannet, saate seda lahendust kasutada mallina, et üldistada oma andmestikuga eelkoolitatud mudeleid ja seejärel käivitada täpsuse parandamiseks hüperparameetrite optimeerimine.

KiirStardi lahendusmallid

Amazon SageMaker JumpStart pakub ühe klõpsuga, otsast lõpuni lahendusi paljudele levinud ML-i kasutusjuhtudele. Saadaolevate lahendusmallide kohta lisateabe saamiseks uurige järgmisi kasutusjuhtumeid.

KiirStart-lahenduse mallid hõlmavad mitmesuguseid kasutusjuhtumeid, millest igaühe all pakutakse mitut erinevat lahendusmalli (see Dokumendi mõistmise lahendus on kasutusjuhtumi “Dokumentidest andmete väljavõte ja analüüsimine” all).

Valige JumpStarti sihtlehelt lahendusmall, mis sobib teie kasutusjuhtumiga kõige paremini. Lisateabe saamiseks konkreetsete lahenduste kohta igal kasutusjuhul ja JumpStarti lahenduse käivitamise kohta vt Lahenduste mallid.

Lahenduse ülevaade

Järgmine pilt näitab, kuidas saate seda lahendust SageMakeri komponentidega kasutada. SageMakeri koolitustöid kasutatakse erinevate NLP-mudelite koolitamiseks ja SageMakeri lõpp-punkte kasutatakse mudelite juurutamiseks igas etapis. Me kasutame Amazoni lihtne salvestusteenus (Amazon S3) koos SageMakeriga treeningandmete ja mudeliartefaktide salvestamiseks ning Amazon CloudWatch koolituse ja lõpp-punktide väljundite logimiseks.

Avage lahendus Dokumendi mõistmine

Liikuge KiirStartis Document Understanding lahenduseni.

Nüüd saame lähemalt tutvuda mõne selle lahendusega sisalduva varaga, alustades demomärkmikuga.

Demomärkmik

Demomärkmikku saate kasutada näidisandmete saatmiseks juba juurutatud mudeli lõpp-punktidele dokumendi kokkuvõtte ja küsimustele vastamise ülesannete jaoks. Demomärkmik võimaldab teil kiiresti saada praktilisi kogemusi näidisandmete päringute abil.

Pärast dokumendi mõistmise lahenduse käivitamist avage demomärkmik, valides valiku Kasutage märkmikus lõpp-punkti.

Sukeldume üksikasjalikumalt selle lahenduse viiest peamisest märkmikust.

Eeldused

In Amazon SageMaker Studio, veenduge, et kasutate PyTorch 1.10 Python 3.8 CPU Optimized pilt/tuum märkmike avamiseks. Koolitus kasutab viit ml.g4dn.2xsuurt eksemplari, seega peaksite tõstma a teenuselimiidi suurendamise taotlus kui teie konto nõuab seda tüüpi piiranguid.

Teksti liigitus

Teksti klassifikatsioon viitab sisendlause klassifitseerimisele ühe koolitusandmestiku klassisildi alla. See märkmik näitab, kuidas kasutada KiirStart API teksti klassifitseerimiseks.

Juurutage ja käivitage eelkoolitatud mudeli põhjal järeldused

Teksti liigitusmudel, mille oleme valinud kasutamiseks, põhineb teksti manustamisel (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) mudel alates TensorFlow jaotur, mis on eelkoolitatud Wikipedia ja BookCorpuse andmekogumites.

Juurutamiseks saadaolev mudel luuakse, lisades teksti manustamismudeli väljundile binaarse klassifikatsioonikihi ja seejärel viimistledes kogu mudelit SST-2 andmestik, mis koosneb positiivsetest ja negatiivsetest filmiarvustustest.

Sellel mudelil järelduste tegemiseks peame esmalt alla laadima järelduste konteineri (deploy_image_uri), järeldusskript (deploy_source_uri) ja eelkoolitatud modell (base_model_uri). Seejärel edastame need parameetritena SageMakeri mudeliobjekti loomiseks, mille saame seejärel juurutada:

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 "

Järgmine kood näitab meie vastuseid:

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

Viimistlege kohandatud andmestikul eelkoolitatud mudelit

Käisime lihtsalt läbi jooksva järelduse eelkoolitatud BERTi mudelil, mis oli seadmel peenhäälestatud SST-2 andmestik.

Järgmisena arutame, kuidas kohandatud andmestiku mudelit täpsustada mis tahes arvu klassidega. Andmekogum, mida me peenhäälestamiseks kasutame, on endiselt SST-2 andmestik. Saate selle andmestiku asendada mis tahes teid huvitava andmekogumiga.

Toome välja koolituse Dockeri konteineri, koolitusalgoritmi allika ja eelkoolitatud mudeli:

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

Algoritmispetsiifiliste hüperparameetrite puhul hangime alustuseks Pythoni sõnastikust treeningu hüperparameetrid, mille algoritm aktsepteerib nende vaikeväärtustega. Saate need kohandatud väärtustega alistada, nagu on näidatud järgmises koodis:

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"

Andmekogum (SST-2) on jagatud koolitus-, valideerimis- ja testikomplektideks, kus koolituskomplekti kasutatakse mudeli sobitamiseks, valideerimiskomplekti kasutatakse hindamismõõdikute arvutamiseks, mida saab kasutada HPO jaoks, ja testikomplekti kasutatakse hoidmisandmetena. mudeli jõudluse hindamiseks. Järgmisena laaditakse koolituse ja valideerimise andmestik üles Amazon S3-sse ja seda kasutatakse treeningu peenhäälestustöö käivitamiseks:

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

Kui peenhäälestustöö on lõpule viidud, juurutame mudeli, teeme järeldamiskatse andmekogumi kohta ja arvutame hindamismõõdikud. Kuna see on binaarne klassifitseerimise ülesanne, kasutame täpsusskoor ja F1 skoor kui hindamismõõdikud. Suurem väärtus näitab paremat jõudlust. Järgmine ekraanipilt näitab meie tulemusi.

Täiustage peenhäälestuse jõudlust veelgi SageMakeri automaatse mudelihäälestusega

Selles etapis näitame, kuidas saate mudeli jõudlust veelgi parandada, viimistledes mudelit SageMakeri automaatse mudelihäälestusega. Automaatne mudeli häälestamine, tuntud ka kui hüperparameetrite optimeerimine (HPO), leiab mudeli parima versiooni, käivitades teie andmestikul mitu treeningtööd koos teie määratud hüperparameetritega. Seejärel valib see hüperparameetrite väärtused, mille tulemuseks on mudel, mis töötab valideerimisandmestikul teie valitud mõõdiku järgi kõige paremini.

Esiteks seadsime eesmärgiks valideerimisandmete täpsusskoori (val_accuracy) ja määratles häälestustöö mõõdikud, määrates objektiivse mõõdiku nime ja regulaaravaldise (regex). Regulaaravaldist kasutatakse algoritmi logiväljundi sobitamiseks ja mõõdikute arvväärtuste hõivamiseks. Järgmisena määrame hüperparameetrite vahemikud, millest valida parimad hüperparameetri väärtused. Seadsime häälestustööde koguarvuks kuus ja jagame need tööd kolmele erinevale Amazon Elastic Compute Cloud (Amazon EC2) eksemplarid paralleelsete häälestustööde käitamiseks. Vaadake järgmist koodi:

# 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

Edastame need väärtused, et luua SageMakeri prognoosija objekt, sarnaselt sellele, mida tegime eelmises peenhäälestuse etapis. Selle asemel, et helistada fit funktsioon Estimator objekti, me läbime Estimator objekt parameetrina Hüperparameetri tuuner ehitaja ja helistage fit selle funktsioon häälestustööde käivitamiseks:

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

Kui häälestustööd on lõpetatud, juurutame mudeli, mis annab valideerimisandmestiku parima hindamismõõdiku skoori, teeme järeldused sama kinnipidamistesti andmestiku kohta, mida tegime eelmises jaotises, ja arvutame hindamismõõdikud.

Tulemused näitavad, et mudeli automaatse häälestamise abil valitud mudel ületab märkimisväärselt eelmises jaotises peenhäälestatud mudelit hoidmiskatse andmestiku osas.

Nimega olemi tuvastamine

Nimetatud olemituvastus (NER) on protsess, mille käigus tuvastatakse ja klassifitseeritakse nimetatud olemid eelnevalt määratletud kategooriatesse, nagu isikute, organisatsioonide, asukohtade ja koguste nimed. NER-i tegelikke kasutusjuhtumeid on palju, näiteks soovitusmootorid, klienditoe piletite kategoriseerimine ja määramine õigesse osakonda, olulise teabe hankimine tervishoius patsientide aruannetest ning sisu klassifitseerimine uudistest ja ajaveebidest.

Juurutage ja käivitage eelkoolitatud mudeli põhjal järeldused

Me kasutame En_core_web_md mudel pärit ruumiline raamatukogu. spaCy on avatud lähtekoodiga NLP-teek, mida saab kasutada erinevate ülesannete jaoks ja millel on NER-i jaoks sisseehitatud meetodid. Kasutame skriptirežiimiga AWS PyTorch Deep Learning Containerit (DLC) ja paigaldame konteineri peale sõltuvusena spaCy teegi.

Järgmiseks skripti sisenemispunkt (argument entry_point.py), mis sisaldab kogu allalaadimiseks ja laadimiseks vajalikku koodi En_core_web_md modelleerida ja teha järeldusi lõpp-punkti saadetud andmete kohta. Lõpuks peame ikkagi pakkuma model_data kui eelkoolitatud järelduste mudel. Kuna eelkoolitatud En_core_web_md mudel laaditakse alla lennult, mis on märgitud sisestusskriptis, pakume tühja arhiivifaili. Pärast lõpp-punkti juurutamist saate SageMaker Pythoni SDK abil lõpp-punkti kutsuda otse sülearvutist Predictor. Vaadake järgmist koodi:

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

Mudeli sisendandmeteks on tekstidokument. Nimega olemi mudel eraldab tekstidokumendist nimisõnade tükid ja nimega olemid ning liigitab need mitmesse erinevasse tüüpi (nt inimesed, kohad ja organisatsioonid). Näidissisend ja väljund on näidatud järgmises koodis. The start_char parameeter näitab vahemiku alguse märginihet ja end_char näitab vahemiku lõppu.

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

Viimistlege kohandatud andmestikul eelkoolitatud mudelit

Selles etapis demonstreerime, kuidas NER-i jaoks eelnevalt väljaõpetatud keelemudeleid oma andmestikul peenhäälestada. Peenhäälestuse samm värskendab mudeli parameetreid, et jäädvustada teie enda andmete omadused ja parandada täpsust. Me kasutame WikiANN (PAN-X) andmestiku peenhäälestamiseks DistilBERT-alus-korpuseta Trafo mudel firmalt Hugging Face.

Andmekogum on jagatud koolitus-, valideerimis- ja testikomplektideks.

Järgmisena täpsustame mudeli hüperparameetrid ja kasutame skriptirežiimiga AWS Hugging Face DLC-d (argument entry_point) peenhäälestustöö käivitamiseks:

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
)

Kui peenhäälestustöö on lõpule viidud, juurutame lõpp-punkti ja esitame sellele lõpp-punktile päringu koos hoidmise testandmetega. Lõpp-punkti päringu tegemiseks tuleb iga tekstistring muuta üheks või mitmeks märgiks ja saata trafo mudelile. Iga luba saab ennustatud nimega olemi märgendi. Kuna iga tekstistringi saab märgistada üheks või mitmeks märgiks, peame dubleerima stringi põhitõe nimega olemi märgendi kõigi sellega seotud märgidega. Kaasasolev märkmik juhendab teid selle saavutamiseks vajalikke samme.

Viimaseks kasutame Hugging Face sisseehitatud hindamismõõdikuid järg hindamisskooride arvutamiseks kinnipidamistesti andmete põhjal. Kasutatavad hindamismõõdikud on üldine täpsus, üldine meeldetuletus, üldine F1 ja täpsus. Järgmine ekraanipilt näitab meie tulemusi.

Täiustage peenhäälestuse jõudlust veelgi SageMakeri automaatse mudelihäälestusega

Sarnaselt teksti klassifitseerimisele demonstreerime, kuidas saate mudeli jõudlust veelgi parandada, viimistledes mudelit SageMakeri automaatse mudelihäälestusega. Häälestustöö käivitamiseks peame määratlema objektiivse mõõdiku, mida tahame kasutada mudeli jõudluse hindamiseks valideerimisandmestiku (antud juhul skoor F1), hüperparameetrite vahemikud parimate hüperparameetrite väärtuste valimiseks, samuti häälestustöö konfiguratsioonid, näiteks korraga käivitatavate häälestustööde maksimaalne arv ja paralleelsete tööde arv:

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)

Kui häälestustööd on lõpetatud, juurutame mudeli, mis annab valideerimisandmestiku parima hindamismõõdiku skoori, teeme järeldused sama kinnipidamistesti andmestiku kohta, mida tegime eelmises jaotises, ja arvutame hindamismõõdikud.

Näeme, et HPO-ga mudel saavutab kõigi mõõdikute puhul oluliselt parema jõudluse.

Küsimusele vastamine

Küsimustele vastamine on kasulik, kui soovite konkreetse teabe saamiseks pärida suures koguses teksti. See võimaldab kasutajal esitada küsimust loomulikus keeles ja saada kohese ja lühikese vastuse. NLP-põhiseid küsimustele vastamise süsteeme saab kasutada otsingumootorites ja telefonivestlusliidestes.

Juurutage ja käivitage eelkoolitatud mudeli põhjal järeldused

Meie eelkoolitatud mudel on väljavõtva küsimustele vastamise (EQA) mudel bert-suur-kasutamata-terve-sõna-maskimise-peenhäälestatud-salk ehitatud Hugging Face'i Transformeri mudelile. Kasutame skriptirežiimiga AWS PyTorchi DLC-d ja installime selle trafod raamatukogu sõltuvusena konteineri peal. Sarnaselt NER-i ülesandega pakume argumendis tühja arhiivifaili model_data sest eelkoolitatud mudel laaditakse alla käigu pealt. Pärast lõpp-punkti juurutamist saate SageMaker Pythoni SDK abil lõpp-punkti kutsuda otse sülearvutist Predictor. Vaadake järgmist koodi:

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

Kõik, mida peame tegema, on konstrueerida sõnastikuobjekt kahe võtmega. context on tekst, millest soovime teavet hankida. question on loomuliku keele päring, mis täpsustab, millise teabe hankimisest oleme huvitatud. Me helistame predict meie ennustajal ja me peaksime saama vastuse lõpp-punktist, mis sisaldab kõige tõenäolisemaid vastuseid:

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

Meil on vastus olemas ja me saame välja printida kõige tõenäolisemad vastused, mis on eelmisest tekstist välja võetud. Igal vastusel on järjestamisel kasutatav usaldusskoor (kuid seda skoori ei tohiks tõlgendada tõenäolise tõenäosusena). Lisaks sõnasõnalisele vastusele saate algsest kontekstist ka vastuse alguse ja lõpu märgiindeksid:

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üüd viimistleme seda mudelit oma kohandatud andmekogumiga, et saada paremaid tulemusi.

Viimistlege kohandatud andmestikul eelkoolitatud mudelit

Selles etapis demonstreerime, kuidas peenhäälestada EQA jaoks eelnevalt koolitatud keelemudeleid teie enda andmestikul. Peenhäälestuse samm värskendab mudeli parameetreid, et jäädvustada teie enda andmete omadused ja parandada täpsust. Me kasutame SQUAD2.0 andmekomplekt teksti manustamismudeli peenhäälestamiseks bert-base-kasutamata alates Hugging Face. Peenhäälestamiseks saadaolev mudel lisab teksti manustamismudelile vastuste eraldamise kihi ja lähtestab kihi parameetrid juhuslikeks väärtusteks. Peenhäälestuse samm peenhäälestab kõiki mudeli parameetreid, et minimeerida ennustusvigu sisendandmetes ja tagastab peenhäälestatud mudeli.

Sarnaselt teksti klassifitseerimise ülesandega on andmestik (SQuAD2.0) jagatud koolituseks, valideerimiseks ja testkomplektiks.

Järgmisena täpsustame mudeli hüperparameetrid ja kasutame KiirStart API peenhäälestustöö käivitamiseks:

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)

Kui peenhäälestustöö on lõpule viidud, juurutame mudeli, teeme järelduse kinnipidamistesti andmestikust ja arvutame hindamismõõdikud. Kasutatud hindamismõõdikud on keskmine täpne sobivusskoor ja keskmine F1 skoor. Järgmine ekraanipilt näitab tulemusi.

Täiustage peenhäälestuse jõudlust veelgi SageMakeri automaatse mudelihäälestusega

Sarnaselt eelmiste osadega kasutame a HyperparameterTuner häälestustööde käivitamise eesmärk:

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

Kui häälestustööd on lõpetatud, juurutame mudeli, mis annab valideerimisandmestiku parima hindamismõõdiku skoori, teeme järeldused sama kinnipidamistesti andmestiku kohta, mida tegime eelmises jaotises, ja arvutame hindamismõõdikud.

Näeme, et HPO-ga mudel näitab hoidmiskatse andmetel oluliselt paremat jõudlust.

Suhte väljatõmbamine

Seoste eraldamine on ülesanne eraldada tekstist semantilised seosed, mis tavaliselt esinevad kahe või enama olemi vahel. Seoste väljavõte mängib olulist rolli struktureeritud teabe hankimisel struktureerimata allikatest, näiteks toortekstist. Selles märkmikus demonstreerime suhete eraldamise kahte kasutusjuhtu.

Viimistlege kohandatud andmestikul eelkoolitatud mudelit

Kasutame suhete ekstraheerimise mudelit, mis on üles ehitatud a BERT-baas-korpuseta mudel kasutades trafosid alates Hugging Face trafod raamatukogu. Peenhäälestuse mudel lisab lineaarse klassifikatsioonikihi, mis võtab teksti manustamismudeli poolt väljastatud märgi manustamise paari ja lähtestab kihi parameetrid juhuslikeks väärtusteks. Peenhäälestuse samm peenhäälestab kõiki mudeli parameetreid, et minimeerida ennustusvigu sisendandmetes ja tagastab peenhäälestatud mudeli.

Andmekogum, mille mudelit täpsustame, on SemEval-2010 8. ülesanne. Peenhäälestusega tagastatud mudelit saab järelduste tegemiseks edasi kasutada.

Andmekogum sisaldab koolitus-, valideerimis- ja testikomplekte.

Kasutame AWS PyTorchi DLC-d koos skriptirežiimiga SageMaker Python SDK-st, kus transformers teek on installitud sõltuvusena konteineri ülaossa. Me määratleme SageMakeri PyTorch hindaja ja hüperparameetrite komplekt, nagu eelkoolitatud mudel, õppimiskiirus ja epohhinumbrid peenhäälestuse tegemiseks. Seoste eraldamise mudeli peenhäälestuse kood on määratletud dokumendis entry_point.py. Vaadake järgmist koodi:

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

Täiustage peenhäälestuse jõudlust veelgi SageMakeri automaatse mudelihäälestusega

Sarnaselt eelmiste osadega kasutame a HyperparameterTuner objekt suhtlemiseks SageMakeri hüperparameetrite häälestamise API-dega. Saame alustada hüperparameetrite häälestamist, helistades numbrile fit meetod:

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

Kui hüperparameetrite häälestustöö on lõpetatud, teeme järelduse ja kontrollime hindamisskoori.

Näeme, et HPO-ga mudel näitab hoidmiskatse andmetel paremat jõudlust.

Dokumendi kokkuvõte

Dokumendi või teksti kokkuvõte on ülesanne koondada suured tekstiandmed väiksemateks tähenduslike lausete alamhulkadeks, mis esindavad algsisu kõige olulisemat või asjakohasemat teavet. Dokumendi kokkuvõte on kasulik tehnika olulise teabe destilleerimiseks suurtest tekstiandmetest mõne lauseni. Teksti kokkuvõtet kasutatakse paljudel kasutusjuhtudel, näiteks dokumentide töötlemisel ning ajaveebidest, artiklitest ja uudistest teabe hankimisel.

See märkmik demonstreerib dokumendi kokkuvõtte mudeli juurutamist T5-alus alates Hugging Face trafod raamatukogu. Samuti testime juurutatud lõpp-punkte tekstiartikli abil ja hindame tulemusi sisseehitatud hindamismõõdiku Hugging Face abil RED.

Sarnaselt küsimustele vastamise ja NER-i märkmikega kasutame me PyTorchModel SageMaker Python SDK-st koos an entry_point.py skript T5-baasmudeli laadimiseks HTTPS-i lõpp-punkti. Pärast lõpp-punkti edukat juurutamist saame ennustusvastuse saamiseks lõpp-punktile saata tekstiartikli:

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

Järgmisena hindame ja võrdleme tekstiartiklit ja kokkuvõtte tulemust mõõdiku ROUGE abil. Arvutatakse kolm hindamismõõdikut: rougeN, rougeLja rougeLsum. rougeN mõõdab sobivuste arvu n-grams mudeli loodud teksti (kokkuvõtte tulemuse) ja a reference (sisestage tekst). Mõõdikud rougeL ja rougeLsum mõõta kõige pikemaid sobivaid sõnade jadasid, otsides loodud ja viidete kokkuvõtetes pikimaid ühiseid alamstringe. Iga mõõdiku jaoks arvutatakse täpsuse, meeldetuletuse ja F1 skoori usaldusvahemikud. Vaadake järgmist koodi.

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

Koristage

Selle lahenduse jaoks loodud ressursse saab kustutada kasutades Kustutage kõik ressursid nuppu SageMaker Studio IDE-st. Igas märkmikus on ka puhastussektsioon lõpp-punktide kustutamise koodiga.

Järeldus

Selles postituses näitasime, kuidas kasutada tipptasemel ML-tehnikaid viie erineva NLP-ülesande lahendamiseks: dokumentide kokkuvõte, teksti klassifitseerimine, küsimused ja vastused, nimega olemi tuvastamine ja suhete eraldamine Kiirstardi abil. Alustage Kiirstardiga kohe!

Autoritest

Dr Xin Huang on Amazon SageMaker JumpStarti ja Amazon SageMakeri sisseehitatud algoritmide rakendusteadlane. Ta keskendub skaleeritavate masinõppe algoritmide arendamisele. Tema uurimishuvid on seotud loomuliku keele töötlemise, tabeliandmete seletatava süvaõppe ja mitteparameetrilise aegruumi klastrite tugeva analüüsiga. Ta on avaldanud palju artikleid ACL-i, ICDM-i, KDD konverentsidel ja Royal Statistical Society: Series A ajakirjas.

Vivek Gangasani on Amazon Web Services'i masinõppelahenduste vanemarhitekt. Ta aitab idufirmadel AI/ML-i rakendusi luua ja kasutusele võtta. Praegu keskendub ta oma tausta ühendamisele konteinerite ja masinõppe vallas, et pakkuda lahendusi MLOps-i, ML-i järelduste ja madala koodiga ML-i jaoks. Vabal ajal meeldib talle proovida uusi restorane ning uurida uusi AI ja süvaõppe suundumusi.

Geremy Cohen on AWS-i lahenduste arhitekt, kes aitab klientidel luua tipptasemel pilvepõhiseid lahendusi. Vabal ajal naudib ta lühikesi jalutuskäike rannas, perega lahe piirkonna avastamist, maja ümber asjade parandamist, maja ümber lõhkumist ja grillimist.

Neelam Koshiya on AWS-i ärilahenduste arhitekt. Tema praegune eesmärk on aidata ärikliente nende pilves kasutuselevõtu teekonnal strateegiliste äritulemuste saavutamiseks. Vabal ajal meeldib talle lugeda ja õues olla.