Az Amazon SageMaker JumpStart segítségével finomhangoláson és HPO-n keresztül azonosíthatja a szöveges dokumentumokból származó kulcsfontosságú betekintést

Az olyan iparágakban működő szervezeteknek, mint a kiskereskedelem, a bankszektor, a pénzügy, az egészségügy, a gyártás és a hitelezés, gyakran rengeteg strukturálatlan szöveges dokumentummal kell megküzdeniük különböző forrásokból, például hírekből, blogokból, termékismertetőkből, ügyfélszolgálati csatornákból és közösségi médiából. Ezek a dokumentumok olyan kritikus információkat tartalmaznak, amelyek kulcsfontosságúak a fontos üzleti döntések meghozatalához. A szervezet növekedésével kihívást jelent a kritikus információk kinyerése ezekből a dokumentumokból. A természetes nyelvi feldolgozás (NLP) és a gépi tanulási (ML) technikák fejlődésével ezekből a szöveges dokumentumokból gyorsan és nagy pontossággal tárhatunk fel értékes ismereteket és összefüggéseket, ezáltal segítve a vállalatokat, hogy időben minőségi üzleti döntéseket hozzanak. A teljesen menedzselt NLP-szolgáltatások szintén felgyorsították az NLP elfogadását. Amazon Comprehend egy teljes körűen felügyelt szolgáltatás, amely lehetővé teszi egyedi NLP-modellek létrehozását, amelyek az Ön igényeihez igazodnak, anélkül, hogy bármilyen ML-szakértelemre lenne szükség.

Ebben a bejegyzésben bemutatjuk, hogyan lehet a legmodernebb ML technikákat felhasználni öt különböző NLP-feladat megoldására: dokumentumösszegzés, szövegbesorolás, kérdések megválaszolása, elnevezett entitás felismerés és kapcsolatkivonás. Mindegyik NLP-feladatnál bemutatjuk, hogyan kell használni Amazon SageMaker a következő műveletek végrehajtásához:

• Telepítsen és futtasson következtetést egy előre betanított modellen
• Finomhangolja az előre betanított modellt egy új egyéni adatkészleten
• Javítsa tovább a finomhangolási teljesítményt SageMaker automatikus modelltuning
• Értékelje a modell teljesítményét a kitartási tesztadatokon különböző értékelési mérőszámokkal

Bár ebben a bejegyzésben öt konkrét NLP-feladattal foglalkozunk, ezt a megoldást sablonként használhatja az előre betanított modellek finomhangolására saját adatkészletével, majd ezt követően a hiperparaméter-optimalizálást futtathatja a pontosság növelése érdekében.

JumpStart megoldássablonok

Amazon SageMaker JumpStart egykattintásos, végpontok közötti megoldásokat kínál számos gyakori ML használati esethez. Az elérhető megoldássablonokkal kapcsolatos további információkért tekintse meg a következő használati eseteket:

A JumpStart megoldássablonok számos felhasználási esetet lefednek, amelyek mindegyike alatt több különböző megoldássablon található (ez a Dokumentumértelmezési megoldás az „Adatok kinyerése és elemzése dokumentumokból” használati eset alatt található).

A JumpStart nyitóoldaláról válassza ki az Ön használati esetének leginkább megfelelő megoldássablont. Az egyes használati esetekre vonatkozó konkrét megoldásokról és a JumpStart megoldás elindításának módjáról lásd: Megoldási sablonok.

Megoldás áttekintése

A következő kép bemutatja, hogyan használhatja ezt a megoldást a SageMaker összetevőkkel. A SageMaker képzési feladatok a különböző NLP-modellek betanítására szolgálnak, a SageMaker-végpontok pedig a modellek telepítésére az egyes szakaszokban. Mi használjuk Amazon egyszerű tárolási szolgáltatás (Amazon S3) a SageMaker mellett a képzési adatok és a modelltermékek tárolására, és amazonfelhőóra a képzési és végponti kimenetek naplózására.

Nyissa meg a Dokumentumértelmezési megoldást

Keresse meg a Document Understanding megoldást a JumpStartban.

Most közelebbről is szemügyre vehetjük az ebben a megoldásban szereplő eszközöket, kezdve a demó notebooktól.

Demo notebook

A demó jegyzetfüzet segítségével példaadatokat küldhet a már telepített modellvégpontokhoz a dokumentum-összegzési és kérdésmegválaszolási feladatokhoz. A bemutató notebook gyorsan lehetővé teszi, hogy gyakorlati tapasztalatokat szerezzen a példaadatok lekérdezésével.

A Document Understanding megoldás elindítása után nyissa meg a bemutató jegyzetfüzetet a kiválasztással Az Endpoint használata a Jegyzetfüzetben.

Merüljünk el mélyebben a megoldás öt fő notebookjában.

Előfeltételek

In Amazon SageMaker Studio, győződjön meg arról, hogy a PyTorch 1.10 Python 3.8 CPU Optimized image/kernel a jegyzetfüzetek megnyitásához. A képzés öt ml.g4dn.2xnagy példányt használ, ezért emelje fel a szolgáltatási limit növelési kérelmet ha fiókja megnövelt korlátokat ír elő ehhez a típushoz.

Szöveges besorolás

A szövegbesorolás egy bemeneti mondat besorolását jelenti a betanítási adatkészlet egyik osztálycímkéjéhez. Ez a jegyzetfüzet bemutatja, hogyan kell használni a JumpStart API szövegosztályozáshoz.

Telepítse és futtassa a következtetést az előre betanított modellen

Az általunk használt szövegosztályozási modell egy szövegbeágyazásra épül (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) modelltől TensorFlow Hub, amely a Wikipédia és a BookCorpus adatkészletein előre kiképzett.

A telepíthető modell úgy jön létre, hogy egy bináris osztályozási réteget csatolnak a szövegbeágyazó modell kimenetéhez, majd a teljes modellt finomhangolják a SST-2 adatkészlet, amely pozitív és negatív filmkritikákat tartalmaz.

Következtetés futtatásához ezen a modellen először le kell töltenünk a következtetési tárolót (deploy_image_uri), következtetési szkript (deploy_source_uri), és előképzett modell (base_model_uri). Ezután ezeket paraméterként adjuk át egy SageMaker modellobjektum példányosításához, amelyet aztán telepíthetünk:

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 "

A következő kód mutatja válaszainkat:

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

Finomhangolja az előre betanított modellt egy egyéni adatkészleten

Most végigmentünk a futó következtetésen egy előre kiképzett BERT modellen, amely finomhangolásra került a SST-2 adatkészlet.

Ezután megvitatjuk, hogyan lehet finomhangolni egy modellt tetszőleges számú osztályt tartalmazó egyéni adatkészleten. A finomhangoláshoz használt adatkészlet továbbra is a SST-2 adatkészlet. Ezt az adatkészletet lecserélheti bármely olyan adatkészletre, amely érdekli.

Lekérjük a betanító Docker tárolót, a betanító algoritmus forrását és az előre betanított modellt:

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

Az algoritmus-specifikus hiperparaméterek esetében először lekérjük a tanító hiperparaméterek Python-szótárát, amelyeket az algoritmus az alapértelmezett értékekkel fogad el. Egyéni értékekkel felülírhatja őket, ahogy az a következő kódban látható:

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"

Az adatkészlet (SST-2) képzési, érvényesítési és tesztkészletekre van felosztva, ahol a betanítási halmazt a modellhez való illesztéshez használják, az érvényesítő készletet a HPO-hoz használható értékelési metrikák kiszámításához, és a tesztkészletet visszatartási adatokként használják. a modell teljesítményének értékeléséhez. Ezután a betanítási és érvényesítési adatkészletet feltöltik az Amazon S3-ra, és felhasználják a finomhangoló képzési feladat elindításához:

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

A finomhangolási feladat befejezése után telepítjük a modellt, lefuttatjuk a következtetést a visszatartási teszt adatkészletén, és kiszámítjuk az értékelési metrikákat. Mivel ez egy bináris osztályozási feladat, a pontossági pontszám és a F1 pontszám mint az értékelési mérőszámok. A nagyobb érték a jobb teljesítményt jelzi. Az alábbi képernyőképen az eredményeink láthatók.

Javítsa tovább a finomhangolási teljesítményt a SageMaker automatikus modellhangolásával

Ebben a lépésben bemutatjuk, hogyan javíthatja tovább a modell teljesítményét a modell SageMaker automatikus modellhangolással történő finomhangolásával. Az automatikus modellhangolás, más néven hiperparaméter-optimalizálás (HPO), úgy találja meg a modell legjobb verzióját, hogy több betanítási feladatot futtat az adatkészleten az Ön által megadott hiperparaméterek skálájával. Ezután kiválasztja azokat a hiperparaméter-értékeket, amelyek a legjobban teljesítő modellt eredményezik az Ön által választott metrika szerint az érvényesítési adatkészleten.

Először az érvényesítési adatok pontossági pontszámaként állítjuk be a célt (val_accuracy), és metrikákat definiált a hangolási feladathoz az objektív metrikanév és egy reguláris kifejezés (regex) megadásával. A reguláris kifejezés az algoritmus naplókimenetének egyeztetésére és a metrikák numerikus értékeinek rögzítésére szolgál. Ezután hiperparaméter-tartományokat adunk meg a legjobb hiperparaméter-értékek kiválasztásához. A hangolási feladatok teljes számát hatban állítjuk be, és ezeket a munkákat három különbözőre osztjuk ki Amazon rugalmas számítási felhő (Amazon EC2) példányok párhuzamos hangolási feladatok futtatásához. Lásd a következő kódot:

# 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

Ezeket az értékeket átadjuk egy SageMaker Estimator objektum példányosításához, hasonlóan ahhoz, amit az előző finomhangolási lépésben tettünk. Ahelyett, hogy felhívná a fit funkció Estimator tárgyat, átadjuk a Estimator objektum paramétereként a HyperparameterTuner kivitelezőt, és hívja a fit funkciója a hangolási munkák elindításához:

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

A hangolási feladatok befejezése után telepítjük azt a modellt, amely a legjobb értékelési metrika pontszámot adja az érvényesítési adatkészleten, következtetéseket hajtunk végre ugyanazon a kitartási tesztadatkészleten, amelyet az előző részben tettünk, és kiszámítjuk az értékelési metrikákat.

Az eredmények azt mutatják, hogy az automatikus modellhangolással kiválasztott modell jelentősen felülmúlja az előző szakaszban finomhangolt modellt egy kitartási teszt adatkészletén.

Elnevezett entitás felismerés

A megnevezett entitások felismerése (NER) a megnevezett entitások észlelésének és előre meghatározott kategóriákba sorolásának folyamata, például személyek, szervezetek, helyek és mennyiségek nevére. A NER-nek számos valós felhasználási esete létezik, például ajánlómotorok, ügyfélszolgálati jegyek kategorizálása és hozzárendelése a megfelelő osztályhoz, lényeges információk kinyerése az egészségügyben a betegjelentésekből, valamint tartalombesorolás hírekből és blogokból.

Telepítse és futtassa a következtetést az előre betanított modellen

Telepítjük a En_core_web_md modell a borsos könyvtár. A spaCy egy nyílt forráskódú NLP-könyvtár, amely különféle feladatokhoz használható, és beépített metódusokkal rendelkezik a NER számára. Egy AWS PyTorch Deep Learning Container-t (DLC) használunk szkript móddal, és a spaCy könyvtárat függőségként telepítjük a tároló tetejére.

Ezután a szkript belépési pontja (argumentum entry_point.py) van megadva, amely tartalmazza a letöltéshez és a betöltéshez szükséges összes kódot En_core_web_md modellezni és következtetéseket levonni a végpontnak küldött adatokra. Végül még biztosítanunk kell model_data mint a következtetés előre betanított modellje. Mert az előképzett En_core_web_md A modell menet közben letöltődik, ami a belépési szkriptben van megadva, üres archív fájlt biztosítunk. A végpont üzembe helyezése után a végpontot közvetlenül a notebookból hívhatja meg a SageMaker Python SDK segítségével. Predictor. Lásd a következő kódot:

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

A modell bemeneti adatai egy szöveges dokumentum. A megnevezett entitásmodell kivonja a főnévi darabokat és elnevezett entitásokat a szöveges dokumentumban, és számos különböző típusba sorolja őket (például emberek, helyek és szervezetek). A példa bemenet és kimenet a következő kódban látható. Az start_char paraméter az span kezdetének karaktereltolását jelzi, és end_char az ív végét jelzi.

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

Finomhangolja az előre betanított modellt egy egyéni adatkészleten

Ebben a lépésben bemutatjuk, hogyan lehet finomhangolni egy előre betanított nyelvi modellt a NER számára a saját adatkészletén. A finomhangolási lépés frissíti a modell paramétereit, hogy rögzítse saját adatainak jellemzőit és javítsa a pontosságot. Használjuk a WikiANN (PAN-X) adatkészlet finomhangolásához DistilBERT-alap-burkolat nélküli A márka Transformer modellje Hugging Face.

Az adatkészlet képzési, érvényesítési és tesztkészletekre van felosztva.

Ezután megadjuk a modell hiperparamétereit, és egy AWS Hugging Face DLC-t használunk szkript móddal (argumentum entry_point) a finomhangolási feladat elindításához:

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
)

A finomhangolási feladat befejezése után telepítünk egy végpontot, és lekérdezzük azt a végpontot a visszatartási tesztadatokkal. A végpont lekérdezéséhez minden szöveges karakterláncot egy vagy több tokenné kell tokenizálni, és el kell küldeni a transzformátormodellnek. Minden token egy előre jelzett elnevezett entitáscímkét kap. Mivel minden szöveges karakterlánc egy vagy több tokenné alakítható, meg kell duplikálnunk a karakterlánc alapigazság nevű entitáscímkéjét az összes hozzá társított tokenhez. A mellékelt jegyzetfüzet végigvezeti az ehhez szükséges lépéseken.

Végül a Hugging Face beépített értékelési mérőszámait használjuk következő értékelési pontszámok kiszámításához a kitartási tesztadatokon. A használt értékelési mérőszámok az általános precizitás, az általános visszahívás, az általános F1 és a pontosság. Az alábbi képernyőképen az eredményeink láthatók.

Javítsa tovább a finomhangolási teljesítményt a SageMaker automatikus modellhangolásával

A szöveges osztályozáshoz hasonlóan bemutatjuk, hogyan javíthatja tovább a modell teljesítményét a modell SageMaker automatikus modellhangolásával történő finomhangolásával. A hangolási feladat futtatásához meg kell határoznunk egy objektív mérőszámot, amelyet használni szeretnénk a modell teljesítményének kiértékeléséhez az érvényesítési adatkészleten (ebben az esetben az F1 pontszám), a hiperparaméter-tartományokat a legjobb hiperparaméter-értékek kiválasztásához, valamint a hangolási feladatok konfigurációit, mint pl. a hangolási feladatok maximális száma és az egyszerre elindítandó párhuzamos jobok száma:

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)

A hangolási feladatok befejezése után telepítjük azt a modellt, amely a legjobb értékelési metrika pontszámot adja az érvényesítési adatkészleten, következtetéseket hajtunk végre ugyanazon a kitartási tesztadatkészleten, amelyet az előző részben tettünk, és kiszámítjuk az értékelési metrikákat.

Láthatjuk, hogy a HPO-val rendelkező modell lényegesen jobb teljesítményt ér el minden mérőszámon.

Kérdés válasz

A kérdések megválaszolása akkor hasznos, ha nagy mennyiségű szöveget szeretne lekérdezni bizonyos információkért. Lehetővé teszi a felhasználó számára, hogy kérdését természetes nyelven fejezze ki, és azonnali és rövid választ kapjon. Az NLP-n alapuló kérdésmegválaszoló rendszerek keresőmotorokban és telefonbeszélgetési felületeken használhatók.

Telepítse és futtassa a következtetést az előre betanított modellen

Az előre betanított modellünk az extraktív kérdésválasz (EQA) modell bert-nagy-betét nélküli-egész szó-maszkolás-finomult-osztag a Hugging Face Transformer modelljére épített. Egy AWS PyTorch DLC-t használunk szkript móddal, és telepítjük a transzformerek könyvtárat a tároló tetején lévő függőségként. A NER feladathoz hasonlóan az argumentumban egy üres archív fájlt adunk meg model_data mert az előre betanított modell menet közben letöltődik. A végpont üzembe helyezése után a végpontot közvetlenül a notebookból hívhatja meg a SageMaker Python SDK segítségével. Predictor. Lásd a következő kódot:

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

Mindössze annyit kell tennünk, hogy összeállítunk egy szótárobjektumot két kulccsal. context az a szöveg, amelyből információkat szeretnénk lekérni. question a természetes nyelvű lekérdezés, amely meghatározza, hogy milyen információkat szeretnénk kinyerni. Hívjuk predict a prediktorunkon, és a legvalószínűbb válaszokat tartalmazó végpontból választ kell kapnunk:

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

Megvan a válasz, és ki tudjuk nyomtatni a legvalószínűbb válaszokat, amelyek az előző szövegből származnak. Minden válasznak van egy megbízhatósági pontszáma a rangsoroláshoz (de ezt a pontszámot nem szabad valós valószínűségként értelmezni). A szó szerinti válaszon kívül a válasz kezdő és záró karakterindexét is megkapja az eredeti kontextusból:

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

Most saját egyéni adatkészletünkkel finomhangoljuk ezt a modellt a jobb eredmények érdekében.

Finomhangolja az előre betanított modellt egy egyéni adatkészleten

Ebben a lépésben bemutatjuk, hogyan lehet finomhangolni egy előre betanított nyelvi modellt az EQA számára a saját adatkészletén. A finomhangolási lépés frissíti a modell paramétereit, hogy rögzítse saját adatainak jellemzőit és javítsa a pontosságot. Használjuk a SQUAD2.0 adatkészlet a szövegbeágyazási modell finomhangolásához bert-alap- uncased a Hugging Face-től. A finomhangolásra rendelkezésre álló modell válaszkivonó réteget csatol a szövegbeágyazási modellhez, és véletlenszerű értékekre inicializálja a rétegparamétereket. A finomhangolási lépés finomhangolja az összes modellparamétert, hogy minimalizálja a bemeneti adatok előrejelzési hibáit, és visszaadja a finomhangolt modellt.

A szöveges osztályozási feladathoz hasonlóan az adatkészlet (SQuAD2.0) képzési, érvényesítési és tesztkészletre van felosztva.

Ezután adjuk meg a modell hiperparamétereit, és használjuk a JumpStart API finomhangolási munka elindításához:

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)

A finomhangolási feladat befejezése után telepítjük a modellt, lefuttatjuk a következtetést a visszatartási teszt adatkészletén, és kiszámítjuk az értékelési metrikákat. A használt értékelési mérőszámok az átlagos pontos egyezési pontszám és az átlagos F1 pontszám. A következő képernyőkép az eredményeket mutatja.

Javítsa tovább a finomhangolási teljesítményt a SageMaker automatikus modellhangolásával

Az előző részekhez hasonlóan használjuk a HyperparameterTuner kifogás a hangolási munkák elindításával kapcsolatban:

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

A hangolási feladatok befejezése után telepítjük azt a modellt, amely a legjobb értékelési metrika pontszámot adja az érvényesítési adatkészleten, következtetéseket hajtunk végre ugyanazon a kitartási tesztadatkészleten, amelyet az előző részben tettünk, és kiszámítjuk az értékelési metrikákat.

Láthatjuk, hogy a HPO-val rendelkező modell lényegesen jobb teljesítményt mutat a kitartási teszt adatain.

Kapcsolat kitermelése

A kapcsolatkinyerés a szövegből szemantikai kapcsolatok kinyerésének feladata, amelyek általában két vagy több entitás között fordulnak elő. A kapcsolatkinyerés fontos szerepet játszik a strukturált információk strukturálatlan forrásokból, például nyers szövegből való kinyerésében. Ebben a jegyzetfüzetben a kapcsolatkivonás két felhasználási esetét mutatjuk be.

Finomhangolja az előre betanított modellt egy egyéni adatkészleten

Egy kapcsolatkivonási modellt használunk, amely a BERT-alap-burkolat nélküli modellből származó transzformátorokat használva Hugging Face transzformátorok könyvtár. A finomhangolási modell egy lineáris osztályozási réteget csatol, amely a szövegbeágyazási modell által kiadott token beágyazások párját veszi fel, és a rétegparamétereket véletlenszerű értékekre inicializálja. A finomhangolási lépés finomhangolja az összes modellparamétert, hogy minimalizálja a bemeneti adatok előrejelzési hibáit, és visszaadja a finomhangolt modellt.

A modell finomhangolására szolgáló adatkészlet az SemEval-2010 8. feladat. A finomhangolással visszaadott modell tovább használható következtetésekhez.

Az adatkészlet képzési, érvényesítési és tesztkészleteket tartalmaz.

Az AWS PyTorch DLC-t a SageMaker Python SDK-ból származó szkript móddal használjuk, ahol a transformers könyvtár függőségként van telepítve a tároló tetejére. Meghatározzuk a SageMaker-t PyTorch becslő és egy sor hiperparaméter, például az előre betanított modell, a tanulási sebesség és a korszakszámok a finomhangolás végrehajtásához. A kapcsolatkivonási modell finomhangolásához szükséges kódot a entry_point.py. Lásd a következő kódot:

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

Javítsa tovább a finomhangolási teljesítményt a SageMaker automatikus modellhangolásával

Az előző részekhez hasonlóan használjuk a HyperparameterTuner objektum a SageMaker hiperparaméter-hangoló API-kkal való interakcióhoz. A hiperparaméter hangolási feladatot elindíthatjuk a fit eljárás:

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

Amikor a hiperparaméter-hangolási feladat befejeződött, következtetést hajtunk végre és ellenőrizzük az értékelési pontszámot.

Láthatjuk, hogy a HPO-val rendelkező modell jobb teljesítményt mutat a kitartási tesztadatokon.

Dokumentum összefoglaló

A dokumentum- vagy szövegösszegzés az a feladat, hogy nagy mennyiségű szöveges adatot sűrítsen értelmes mondatok kisebb részhalmazába, amelyek az eredeti tartalomban a legfontosabb vagy legfontosabb információkat képviselik. A dokumentum-összegzés hasznos technika a fontos információk nagy mennyiségű szöveges adatból néhány mondatra történő lepárolására. A szöveges összegzést számos felhasználási esetben alkalmazzák, például a dokumentumfeldolgozásban és a blogokból, cikkekből és hírekből származó információk kinyerésében.

Ez a jegyzetfüzet bemutatja a dokumentum-összefoglaló modell telepítését T5-alap tól Hugging Face transzformátorok könyvtár. A telepített végpontokat szöveges cikk segítségével is teszteljük, az eredményeket pedig a Hugging Face beépített értékelési mérőszámával értékeljük ki. PIROS.

A kérdésfelelőshöz és a NER-füzetekhez hasonlóan mi a PyTorchModel a SageMaker Python SDK-ból egy entry_point.py parancsfájl a T5-alapú modell betöltéséhez egy HTTPS-végpontra. A végpont sikeres üzembe helyezése után szöveges cikket küldhetünk a végpontnak, hogy előrejelzési választ kapjunk:

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

Ezután kiértékeljük és összehasonlítjuk a szöveges cikket és az összegzés eredményét a ROUGE mérőszám segítségével. Három értékelési mérőszámot számítanak ki: rougeN, rougeLés rougeLsum. rougeN méri az egyezések számát n-grams a modell által generált szöveg (összegzés eredménye) és a reference (beviteli szöveg). A mérőszámok rougeL és a rougeLsum mérje meg a szavak leghosszabb egyező sorozatait úgy, hogy megkeresi a leghosszabb közös részstringeket a generált és hivatkozási összefoglalókban. Minden egyes mérőszámhoz kiszámítják a pontosság, a visszahívás és az F1 pontszám konfidenciaintervallumát. Tekintse meg a következő kódot:

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

Tisztítsuk meg

A megoldáshoz létrehozott erőforrások a következővel törölhetők Törölje az összes erőforrást gombot a SageMaker Studio IDE-ből. Minden jegyzetfüzet tartalmaz egy tisztító részt is a végpontok törléséhez szükséges kóddal.

Következtetés

Ebben a bejegyzésben bemutattuk, hogyan lehet a legmodernebb ML technikákat felhasználni öt különböző NLP-feladat megoldására: dokumentumösszegzés, szövegosztályozás, kérdések és válaszok, elnevezett entitás felismerés és kapcsolatkivonás a Jumpstart segítségével. Kezdje el most a Jumpstartot!

A szerzőkről

Dr. Xin Huang az Amazon SageMaker JumpStart és az Amazon SageMaker beépített algoritmusainak alkalmazott tudósa. A skálázható gépi tanulási algoritmusok fejlesztésére összpontosít. Kutatási területe a természetes nyelvi feldolgozás, a táblázatos adatok magyarázható mély tanulása és a nem-paraméteres tér-idő klaszterezés robusztus elemzése. Számos közleményt publikált az ACL, ICDM, KDD konferenciákon és a Royal Statistical Society: Series A folyóiratban.

Vivek Gangasani az Amazon Web Services vezető gépi tanulási megoldások építésze. Segít a startupoknak AI/ML alkalmazások létrehozásában és működésében. Jelenleg a konténerek és a gépi tanulás területén szerzett hátterének ötvözésére összpontosít, hogy megoldásokat hozzon létre az MLOps, az ML Inference és az alacsony kódú ML területén. Szabadidejében szívesen kipróbál új éttermeket, és fedezi fel a mesterséges intelligencia és a mély tanulás feltörekvő trendjeit.

Geremy Cohen az AWS megoldástervezője, ahol segít ügyfeleinek élvonalbeli, felhőalapú megoldások kidolgozásában. Szabadidejében szeret rövid sétákat tenni a tengerparton, családjával felfedezni az öböl környékét, megjavítani a ház körüli dolgokat, összetörni a ház körüli dolgokat és grillezni.

Neelam Koshiya az AWS vállalati megoldások tervezője. Jelenleg arra törekszik, hogy segítse a vállalati ügyfeleket a felhőbe való áttérésük során a stratégiai üzleti eredmények érdekében. Szabadidejében szeret olvasni és a szabadban lenni.