Identificați informații cheie din documentele text prin reglaj fin și HPO cu Amazon SageMaker JumpStart

Organizațiile din industrii precum comerțul cu amănuntul, bancar, finanțe, asistență medicală, producție și creditare trebuie adesea să se confrunte cu cantități mari de documente text nestructurate care provin din diverse surse, cum ar fi știri, bloguri, recenzii de produse, canale de asistență pentru clienți și rețele sociale. Aceste documente conțin informații esențiale care sunt esențiale pentru luarea unor decizii importante de afaceri. Pe măsură ce o organizație crește, devine o provocare să extragi informații critice din aceste documente. Odată cu progresul tehnicilor de procesare a limbajului natural (NLP) și de învățare automată (ML), putem descoperi informații și conexiuni valoroase din aceste documente textuale rapid și cu o acuratețe ridicată, ajutând astfel companiile să ia decizii de afaceri de calitate la timp. Serviciile NLP gestionate complet au accelerat, de asemenea, adoptarea NLP. Amazon Comprehend este un serviciu complet gestionat care vă permite să construiți modele NLP personalizate care sunt specifice cerințelor dvs., fără a fi nevoie de nicio experiență ML.

În această postare, demonstrăm cum să folosim tehnici de ML de ultimă generație pentru a rezolva cinci sarcini NLP diferite: rezumarea documentelor, clasificarea textului, răspunsul la întrebări, recunoașterea entității numite și extragerea relațiilor. Pentru fiecare dintre aceste sarcini NLP, demonstrăm cum se utilizează Amazon SageMaker pentru a efectua următoarele acțiuni:

• Implementați și rulați inferența pe un model pre-antrenat
• Ajustați modelul pre-antrenat pe un nou set de date personalizat
• Îmbunătățiți în continuare performanța de reglare fină cu Ajustarea automată a modelului SageMaker
• Evaluați performanța modelului cu privire la datele de testare hold-out cu diverse metrici de evaluare

Deși acoperim cinci sarcini NLP specifice în această postare, puteți utiliza această soluție ca șablon pentru a generaliza reglarea fină a modelelor pre-antrenate cu propriul set de date și, ulterior, să rulați optimizarea hiperparametrului pentru a îmbunătăți acuratețea.

Șabloane de soluție JumpStart

Amazon SageMaker JumpStart oferă soluții end-to-end cu un singur clic pentru multe cazuri comune de utilizare ML. Explorați următoarele cazuri de utilizare pentru mai multe informații despre șabloanele de soluții disponibile:

Șabloanele de soluție JumpStart acoperă o varietate de cazuri de utilizare, sub fiecare dintre acestea fiind oferite mai multe șabloane de soluție diferite (această soluție de înțelegere a documentelor se află în cazul de utilizare „Extrage și analizează date din documente”).

Alegeți șablonul de soluție care se potrivește cel mai bine cazului dvs. de utilizare din pagina de destinație JumpStart. Pentru mai multe informații despre soluții specifice pentru fiecare caz de utilizare și despre cum să lansați o soluție JumpStart, consultați Șabloane de soluții.

Prezentare generală a soluțiilor

Următoarea imagine demonstrează cum puteți utiliza această soluție cu componentele SageMaker. Joburile de instruire SageMaker sunt folosite pentru a antrena diferitele modele NLP, iar punctele finale SageMaker sunt folosite pentru a implementa modelele în fiecare etapă. Folosim Serviciul Amazon de stocare simplă (Amazon S3) alături de SageMaker pentru a stoca datele de antrenament și artefactele modelului și Amazon CloudWatch pentru a înregistra rezultatele antrenamentului și ale punctelor finale.

Deschideți soluția Document Understanding

Navigați la soluția Document Understanding în JumpStart.

Acum putem arunca o privire mai atentă asupra unora dintre activele care sunt incluse în această soluție, începând cu notebook-ul demo.

Notebook demonstrativ

Puteți utiliza blocnotesul demonstrativ pentru a trimite date exemple către punctele finale de model deja implementate pentru sarcinile de rezumare a documentelor și de răspuns la întrebări. Notebook-ul demonstrativ vă permite rapid să obțineți experiență practică prin interogarea datelor exemplu.

După ce lansați soluția Document Understanding, deschideți blocnotesul demonstrativ alegând Utilizați Endpoint în Notebook.

Să ne aprofundăm în fiecare dintre cele cinci notebook-uri principale pentru această soluție.

Cerințe preliminare

In Amazon SageMaker Studio, asigurați-vă că utilizați PyTorch 1.10 Python 3.8 CPU Optimized imagine/kernel pentru a deschide caietele. Antrenamentul utilizează cinci instanțe ml.g4dn.2xlarge, așa că ar trebui să ridicați a cerere de creștere a limitei de serviciu dacă contul dvs. necesită limite crescute pentru acest tip.

Clasificarea textului

Clasificarea textului se referă la clasificarea unei propoziții de intrare la una dintre etichetele de clasă ale setului de date de antrenament. Acest caiet demonstrează cum se utilizează JumpStart API pentru clasificarea textului.

Implementați și rulați inferența pe modelul pre-antrenat

Modelul de clasificare a textului pe care am ales să-l folosim este construit pe o încorporare a textului (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) model din TensorFlow Hub, care este pre-antrenat pe seturile de date Wikipedia și BookCorpus.

Modelul disponibil pentru implementare este creat prin atașarea unui strat de clasificare binar la rezultatul modelului de încorporare a textului, iar apoi ajustarea fină a întregului model pe SST-2 set de date, care constă din recenzii pozitive și negative ale filmelor.

Pentru a rula inferența pe acest model, trebuie mai întâi să descarcăm containerul de inferență (deploy_image_uri), script de inferență (deploy_source_uri), și model pre-antrenat (base_model_uri). Apoi îi trecem ca parametri pentru a instanția un obiect model SageMaker, pe care apoi îl putem implementa:

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 "

Următorul cod arată răspunsurile noastre:

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

Ajustați modelul pre-antrenat pe un set de date personalizat

Tocmai am trecut prin rularea inferenței pe un model BERT pre-antrenat, care a fost reglat fin pe SST-2 set de date.

În continuare, vom discuta cum să reglam un model pe un set de date personalizat cu orice număr de clase. Setul de date pe care îl folosim pentru reglare fină este încă SST-2 set de date. Puteți înlocui acest set de date cu orice set de date care vă interesează.

Preluăm containerul Docker de antrenament, sursa algoritmului de antrenament și modelul pre-antrenat:

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

Pentru hiperparametrii specifici algoritmului, începem prin a prelua un dicționar Python al hiperparametrilor de antrenament pe care algoritmul îi acceptă cu valorile lor implicite. Le puteți înlocui cu valori personalizate, așa cum se arată în următorul cod:

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"

Setul de date (SST-2) este împărțit în seturi de instruire, validare și testare, unde setul de antrenament este utilizat pentru a se potrivi modelului, setul de validare este utilizat pentru a calcula valorile de evaluare care pot fi utilizate pentru HPO, iar setul de testare este utilizat ca date de așteptare pentru evaluarea performanței modelului. Apoi, trenul și setul de date de validare sunt încărcate pe Amazon S3 și utilizate pentru a lansa jobul de instruire de reglare fină:

# Create SageMaker Estimator instance
tc_estimator = Estimator(
    role=role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
    output_path=s3_output_location,
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
    base_job_name=training_job_name,
)

training_data_path_updated = f"s3://{config.S3_BUCKET}/{prefix}/train"
# Launch a SageMaker Training job by passing s3 path of the training data
tc_estimator.fit({"training": training_data_path_updated}, logs=True)

După ce sarcina de reglare fină este finalizată, implementăm modelul, rulăm inferența asupra setului de date de testare și calculăm valorile de evaluare. Deoarece este o sarcină de clasificare binară, folosim scorul de precizie și Scor F1 ca metrici de evaluare. O valoare mai mare indică o performanță mai bună. Următoarea captură de ecran arată rezultatele noastre.

Îmbunătățiți și mai mult performanța de reglare fină cu reglarea automată a modelului SageMaker

În acest pas, demonstrăm cum puteți îmbunătăți și mai mult performanța modelului prin reglarea fină a modelului cu reglarea automată a modelului SageMaker. Reglarea automată a modelului, cunoscută și sub denumirea de optimizare a hiperparametrilor (HPO), găsește cea mai bună versiune a unui model prin rularea mai multor joburi de antrenament pe setul de date cu o gamă de hiperparametri pe care o specificați. Apoi alege valorile hiperparametrului care rezultă într-un model care are cele mai bune performanțe, măsurate de o metrică pe care o alegeți, pe setul de date de validare.

În primul rând, am stabilit obiectivul ca scorul de acuratețe al datelor de validare (val_accuracy) și valori definite pentru jobul de reglare prin specificarea numelui metricii obiectiv și a unei expresii regulate (regex). Expresia regulată este utilizată pentru a se potrivi cu rezultatul jurnalului algoritmului și pentru a capta valorile numerice ale valorilor. Apoi, specificăm intervale de hiperparametri pentru a selecta cele mai bune valori ale hiperparametrului. Am stabilit numărul total de lucrări de reglare la șase și le distribuim pe trei diferite Cloud Elastic de calcul Amazon (Amazon EC2) instanțe pentru rularea joburilor de reglare paralelă. Vezi următorul cod:

# 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

Transmitem acele valori pentru a instanția un obiect SageMaker Estimator, similar cu ceea ce am făcut în pasul anterior de reglare fină. În loc să suni la fit funcția Estimator obiect, trecem de Estimator obiect în ca parametru al HyperparameterTuner constructor și apelați fit funcția acestuia de a lansa joburi de reglare:

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

După ce lucrările de reglare sunt finalizate, implementăm modelul care oferă cel mai bun punctaj de evaluare pentru setul de date de validare, efectuăm inferențe pe același set de date de test de rezistență pe care l-am făcut în secțiunea anterioară și calculăm valorile de evaluare.

Rezultatele arată că modelul selectat prin reglarea automată a modelului depășește semnificativ modelul reglat fin în secțiunea anterioară pe un set de date de testare rezistentă.

Recunoașterea entității denumite

Recunoașterea entităților numite (NER) este procesul de detectare și clasificare a entităților numite în categorii predefinite, cum ar fi numele persoanelor, organizațiilor, locațiile și cantitățile. Există multe cazuri de utilizare în lumea reală pentru NER, cum ar fi motoarele de recomandare, clasificarea și atribuirea tichetelor de asistență pentru clienți către departamentul potrivit, extragerea informațiilor esențiale din rapoartele pacienților din asistența medicală și clasificarea conținutului din știri și bloguri.

Implementați și rulați inferența pe modelul pre-antrenat

Desfășurăm En_core_web_md model din spațios bibliotecă. spaCy este o bibliotecă NLP open-source care poate fi utilizată pentru diverse sarcini și are metode încorporate pentru NER. Folosim un AWS PyTorch Deep Learning Container (DLC) cu un mod script și instalăm biblioteca spaCy ca dependență deasupra containerului.

Apoi, un punct de intrare pentru script (argument entry_point.py) este specificat, care conține tot codul de descărcat și încărcat En_core_web_md modelați și efectuați inferențe asupra datelor care sunt trimise la punctul final. În sfârșit, mai trebuie să oferim model_data ca model pre-antrenat pentru inferență. Pentru că pre-antrenați En_core_web_md modelul este descărcat din mers, ceea ce este specificat în scriptul de intrare, oferim un fișier de arhivă gol. După ce punctul final este implementat, puteți invoca punctul final direct din blocnotes folosind SDK-ul SageMaker Python Predictor. Consultați următorul cod:

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

Datele de intrare pentru model sunt un document textual. Modelul de entitate numită extrage bucăți de substantive și entități denumite din documentul textual și le clasifică într-un număr de tipuri diferite (cum ar fi oameni, locuri și organizații). Exemplul de intrare și ieșire sunt afișate în codul următor. The start_char parametrul indică decalajul de caractere pentru începutul intervalului și end_char indică sfârșitul intervalului.

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

Ajustați modelul pre-antrenat pe un set de date personalizat

În acest pas, demonstrăm cum să reglați fin un model de limbaj pre-antrenat pentru NER pe propriul set de date. Pasul de reglare fină actualizează parametrii modelului pentru a capta caracteristicile propriilor date și pentru a îmbunătăți acuratețea. Noi folosim WikiANN (PAN-X) setul de date pentru a regla fin DistilBERT-bază-necarcată Model de transformator de la Hugging Face.

Setul de date este împărțit în seturi de instruire, validare și testare.

Apoi, specificăm hiperparametrii modelului și folosim un DLC AWS Hugging Face cu un mod script (argument entry_point) pentru a declanșa lucrarea de reglare fină:

hyperparameters = {
    "pretrained-model": "distilbert-base-uncased",
    "learning-rate": 2e-6,
    "num-train-epochs": 2,
    "batch-size": 16,
    "weight-decay": 1e-5,
    "early-stopping-patience": 2,
}

ner_estimator = HuggingFace(
    pytorch_version='1.10.2',
    py_version='py38',
    transformers_version="4.17.0",
    entry_point='training.py',
    source_dir='../containers/entity_recognition/finetuning',
    hyperparameters=hyperparameters,
    role=aws_role,
    instance_count=1,
    instance_type=training_instance_type,
    output_path=f"s3://{bucket}/{prefix}/output",
    code_location=f"s3://{bucket}/{prefix}/output",
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
    sagemaker_session=sess,
    volume_size=30,
    env={
        'MMS_DEFAULT_RESPONSE_TIMEOUT': '500'
    },
    base_job_name = training_job_name
)

După ce sarcina de reglare fină este finalizată, implementăm un punct final și interogăm acel punct final cu datele de testare. Pentru a interoga punctul final, fiecare șir de text trebuie să fie tokenizat în unul sau mai multe simboluri și trimis la modelul de transformator. Fiecare jeton primește o etichetă de entitate numită prezisă. Deoarece fiecare șir de text poate fi tokenizat în unul sau mai multe jetoane, trebuie să duplicăm eticheta de entitate numită adevărul de bază a șirului la toate jetoanele care îi sunt asociate. Notebook-ul furnizat vă ghidează prin pașii pentru a realiza acest lucru.

În cele din urmă, folosim valorile de evaluare încorporate Hugging Face secveval pentru a calcula scorurile de evaluare pe datele testului hold-out. Valorile de evaluare utilizate sunt precizia generală, reamintirea generală, F1 generală și acuratețea. Următoarea captură de ecran arată rezultatele noastre.

Îmbunătățiți și mai mult performanța de reglare fină cu reglarea automată a modelului SageMaker

Similar cu clasificarea textului, demonstrăm cum puteți îmbunătăți și mai mult performanța modelului prin reglarea fină a modelului cu reglarea automată a modelului SageMaker. Pentru a rula jobul de reglare, trebuie să definim o metrică obiectivă pe care dorim să o folosim pentru evaluarea performanței modelului pe setul de date de validare (scorul F1 în acest caz), intervale de hiperparametri pentru a selecta cele mai bune valori ale hiperparametrului, precum și configurațiile jobului de reglare, cum ar fi numărul maxim de lucrări de reglare și numărul de lucrări paralele de lansat simultan:

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)

După ce lucrările de reglare sunt finalizate, implementăm modelul care oferă cel mai bun punctaj de evaluare pentru setul de date de validare, efectuăm inferențe pe același set de date de test de rezistență pe care l-am făcut în secțiunea anterioară și calculăm valorile de evaluare.

Putem vedea că modelul cu HPO realizează performanțe semnificativ mai bune în toate valorile.

Răspuns la întrebare

Răspunsul la întrebări este util atunci când doriți să interogați o cantitate mare de text pentru informații specifice. Permite unui utilizator să exprime o întrebare în limbaj natural și să obțină un răspuns imediat și scurt. Sistemele de răspuns la întrebări alimentate de NLP pot fi utilizate în motoarele de căutare și interfețele de conversație telefonică.

Implementați și rulați inferența pe modelul pre-antrenat

Modelul nostru pre-antrenat este modelul extractiv cu răspunsuri la întrebări (EQA). bert-large-uncased-tot-word-masking-finetuned-squad construit pe un model Transformer de la Hugging Face. Folosim un DLC AWS PyTorch cu un mod script și instalăm transformatoare biblioteca ca o dependență deasupra containerului. Similar cu sarcina NER, oferim un fișier de arhivă gol în argument model_data deoarece modelul pre-antrenat se descarcă din mers. După ce punctul final este implementat, puteți invoca punctul final direct din blocnotes folosind SDK-ul SageMaker Python Predictor. Consultați următorul cod:

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

Tot ce trebuie să facem este să construim un obiect dicționar cu două chei. context este textul din care dorim să obținem informații. question este interogarea în limbaj natural care specifică ce informații suntem interesați să extragem. Noi sunam predict pe predictorul nostru și ar trebui să obținem un răspuns de la punctul final care conține cele mai probabile răspunsuri:

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

Avem răspunsul și putem tipări cele mai probabile răspunsuri care au fost extrase din textul precedent. Fiecare răspuns are un scor de încredere folosit pentru clasare (dar acest scor nu trebuie interpretat ca o probabilitate adevărată). În plus față de răspunsul textual, obțineți și indexurile caracterelor de început și de sfârșit ale răspunsului din contextul original:

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

Acum reglam acest model cu propriul nostru set de date personalizate pentru a obține rezultate mai bune.

Ajustați modelul pre-antrenat pe un set de date personalizat

În acest pas, demonstrăm cum să ajustați un model lingvistic pre-antrenat pentru EQA pe propriul set de date. Pasul de reglare fină actualizează parametrii modelului pentru a capta caracteristicile propriilor date și pentru a îmbunătăți acuratețea. Noi folosim SQuAD2.0 set de date pentru a regla fin un model de încorporare a textului bert-bază-necasată din Hugging Face. Modelul disponibil pentru reglare fină atașează un strat de extragere a răspunsului la modelul de încorporare a textului și inițializează parametrii stratului la valori aleatorii. Pasul de reglare fină reglează fin toți parametrii modelului pentru a minimiza eroarea de predicție a datelor de intrare și returnează modelul reglat fin.

Similar cu sarcina de clasificare a textului, setul de date (SQuAD2.0) este împărțit în set de instruire, validare și test.

Apoi, specificăm hiperparametrii modelului și folosim JumpStart API pentru a declanșa o lucrare de reglare fină:

hyperparameters = {'epochs': '3', 'adam-learning-rate': '2e-05', 'batch-size': '16'}

eqa_estimator = Estimator(
    role=role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
    output_path=s3_output_location,
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
    base_job_name=training_job_name,
    debugger_hook_config=False,
)

training_data_path_updated = f"s3://{config.S3_BUCKET}/{prefix}/train"
# Launch a SageMaker Training job by passing s3 path of the training data
eqa_estimator.fit({"training": training_data_path_updated}, logs=True)

După ce sarcina de reglare fină este finalizată, implementăm modelul, rulăm inferența asupra setului de date de testare și calculăm valorile de evaluare. Valorile de evaluare utilizate sunt scorul mediu de potrivire exactă și scorul mediu F1. Următoarea captură de ecran arată rezultatele.

Îmbunătățiți și mai mult performanța de reglare fină cu reglarea automată a modelului SageMaker

Similar cu secțiunile anterioare, folosim a HyperparameterTuner obiect pentru a lansa joburi de reglare:

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

După ce lucrările de reglare sunt finalizate, implementăm modelul care oferă cel mai bun punctaj de evaluare pentru setul de date de validare, efectuăm inferențe pe același set de date de test de rezistență pe care l-am făcut în secțiunea anterioară și calculăm valorile de evaluare.

Putem vedea că modelul cu HPO arată o performanță semnificativ mai bună în ceea ce privește datele de testare.

Extragerea relatiei

Extragerea relațiilor este sarcina de a extrage relații semantice din text, care apar de obicei între două sau mai multe entități. Extragerea relațiilor joacă un rol important în extragerea informațiilor structurate din surse nestructurate, cum ar fi textul brut. În acest caiet, demonstrăm două cazuri de utilizare ale extragerii relațiilor.

Ajustați modelul pre-antrenat pe un set de date personalizat

Folosim un model de extracție a relațiilor construit pe a BERT-bază-necarcată model folosind transformatoare de la Transformatoare Hugging Face bibliotecă. Modelul pentru reglare fină atașează un strat de clasificare liniar care preia o pereche de înglobări de simboluri generate de modelul de încorporare de text și inițializează parametrii stratului la valori aleatorii. Pasul de reglare fină reglează fin toți parametrii modelului pentru a minimiza eroarea de predicție a datelor de intrare și returnează modelul reglat fin.

Setul de date pe care îl reglam fin modelul este SemEval-2010 Sarcina 8. Modelul returnat prin reglare fină poate fi implementat în continuare pentru inferență.

Setul de date conține seturi de instruire, validare și testare.

Folosim DLC-ul AWS PyTorch cu un mod script din SDK-ul SageMaker Python, unde transformers biblioteca este instalată ca dependență deasupra containerului. Noi definim SageMaker PyTorch estimator și un set de hiperparametri, cum ar fi modelul pre-antrenat, rata de învățare și numerele de epocă pentru a efectua reglarea fină. Codul pentru reglarea fină a modelului de extracție a relațiilor este definit în entry_point.py. Consultați următorul cod:

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

Îmbunătățiți și mai mult performanța de reglare fină cu reglarea automată a modelului SageMaker

Similar cu secțiunile anterioare, folosim a HyperparameterTuner obiect pentru a interacționa cu API-urile de reglare a hiperparametrilor SageMaker. Putem începe lucrarea de reglare a hiperparametrului apelând la fit metodă:

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

Când lucrarea de reglare a hiperparametrului este finalizată, efectuăm inferență și verificăm scorul de evaluare.

Putem vedea că modelul cu HPO arată o performanță mai bună în ceea ce privește datele de testare.

Rezumatul documentului

Rezumarea documentelor sau a textului este sarcina de a condensa cantități mari de date text într-un subset mai mic de propoziții semnificative care reprezintă cele mai importante sau relevante informații din conținutul original. Rezumarea documentelor este o tehnică utilă pentru a distila informații importante din cantități mari de date text în câteva propoziții. Rezumatul textului este utilizat în multe cazuri de utilizare, cum ar fi procesarea documentelor și extragerea de informații din bloguri, articole și știri.

Acest notebook demonstrează implementarea modelului de rezumare a documentelor T5-bază de la Transformatoare Hugging Face bibliotecă. Testăm, de asemenea, punctele finale implementate folosind un articol text și evaluăm rezultatele utilizând metrica de evaluare încorporată Hugging Face ROȘU.

Similar cu caietele cu răspunsuri la întrebări și caietele NER, folosim PyTorchModel de la SageMaker Python SDK împreună cu un entry_point.py script pentru a încărca modelul de bază T5 la un punct final HTTPS. După ce punctul final este implementat cu succes, putem trimite un articol text către punctul final pentru a obține un răspuns de predicție:

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

Apoi, evaluăm și comparăm articolul text și rezultatul rezumatului utilizând metrica ROUGE. Sunt calculate trei metrici de evaluare: rougeN, rougeL, și rougeLsum. rougeN măsoară numărul de potriviri n-grams între textul generat de model (rezultatul rezumatului) și a reference (Introdu textul). Valorile rougeL și rougeLsum măsurați cele mai lungi secvențe de cuvinte care se potrivesc căutând cele mai lungi subșiruri comune în rezumatele generate și de referință. Pentru fiecare măsură, sunt calculate intervalele de încredere pentru precizie, reamintire și scor F1. Consultați următorul cod:

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

A curăța

Resursele create pentru această soluție pot fi șterse folosind Ștergeți toate resursele butonul din SageMaker Studio IDE. Fiecare blocnotes oferă, de asemenea, o secțiune de curățare cu codul pentru ștergerea punctelor finale.

Concluzie

În această postare, am demonstrat cum să folosim tehnici de ML de ultimă generație pentru a rezolva cinci sarcini NLP diferite: rezumarea documentelor, clasificarea textului, întrebări și răspunsuri, recunoașterea entităților numite și extragerea relațiilor folosind Jumpstart. Începeți acum cu Jumpstart!

Despre Autori

Dr. Xin Huang este un om de știință aplicat pentru algoritmii încorporați Amazon SageMaker JumpStart și Amazon SageMaker. El se concentrează pe dezvoltarea de algoritmi scalabili de învățare automată. Interesele sale de cercetare sunt în domeniul procesării limbajului natural, al învățării profunde explicabile pe date tabulare și al analizei robuste a grupării neparametrice spațiu-timp. A publicat multe lucrări în ACL, ICDM, conferințe KDD și Royal Statistical Society: Series A journal.

Vivek Gangasani este arhitect senior de soluții de învățare automată la Amazon Web Services. El ajută startup-urile să construiască și să operaționalizeze aplicații AI/ML. În prezent, se concentrează pe combinarea experienței sale în Containers și Machine Learning pentru a oferi soluții pentru MLOps, ML Inference și low-code ML. În timpul liber, îi place să încerce restaurante noi și să exploreze tendințele emergente în AI și învățarea profundă.

Geremy Cohen este arhitect de soluții cu AWS, unde îi ajută pe clienți să construiască soluții de ultimă oră, bazate pe cloud. În timpul liber, se bucură de plimbări scurte pe plajă, de a explora zona golfului împreună cu familia, de a repara lucrurile prin casă, de a sparge lucrurile din jurul casei și de a face grătar.

Neelam Koshiya este un arhitect de soluții pentru întreprinderi la AWS. Obiectivul ei actual este de a ajuta clienții întreprinderilor în călătoria lor de adoptare a cloud-ului pentru rezultate strategice de afaceri. În timpul liber, îi place să citească și să fie în aer liber.