Identificeer belangrijke inzichten uit tekstdocumenten door middel van fijnafstemming en HPO met Amazon SageMaker JumpStart

Organisaties in verschillende sectoren, zoals de detailhandel, het bankwezen, de financiële wereld, de gezondheidszorg, de productie en de kredietverlening, hebben vaak te maken met enorme hoeveelheden ongestructureerde tekstdocumenten die afkomstig zijn uit verschillende bronnen, zoals nieuws, blogs, productrecensies, klantenondersteuningskanalen en sociale media. Deze documenten bevatten kritieke informatie die essentieel is voor het nemen van belangrijke zakelijke beslissingen. Naarmate een organisatie groeit, wordt het een uitdaging om kritieke informatie uit deze documenten te halen. Met de vooruitgang van natuurlijke taalverwerking (NLP) en machine learning (ML) technieken, kunnen we snel en met hoge nauwkeurigheid waardevolle inzichten en verbanden uit deze tekstuele documenten halen, waardoor bedrijven worden geholpen om op tijd hoogwaardige zakelijke beslissingen te nemen. Volledig beheerde NLP-services hebben ook de acceptatie van NLP versneld. Amazon begrijpt het is een volledig beheerde service waarmee u aangepaste NLP-modellen kunt bouwen die specifiek zijn voor uw vereisten, zonder dat u enige ML-expertise nodig heeft.

In dit bericht laten we zien hoe u geavanceerde ML-technieken kunt gebruiken om vijf verschillende NLP-taken op te lossen: documentsamenvatting, tekstclassificatie, vraagantwoorden, herkenning van benoemde entiteiten en extractie van relaties. Voor elk van deze NLP-taken laten we zien hoe te gebruiken Amazon Sage Maker om de volgende acties uit te voeren:

• Implementeer en voer inferentie uit op een vooraf getraind model
• Verfijn het vooraf getrainde model op een nieuwe aangepaste dataset
• Verbeter de fijnafstellingsprestaties verder met Automatische afstemming van SageMaker-modellen
• Evalueer de modelprestaties op de hold-out testgegevens met verschillende evaluatiestatistieken

Hoewel we in dit bericht vijf specifieke NLP-taken behandelen, kunt u deze oplossing gebruiken als een sjabloon om fijnafstemming van vooraf getrainde modellen te generaliseren met uw eigen dataset en vervolgens hyperparameteroptimalisatie uit te voeren om de nauwkeurigheid te verbeteren.

JumpStart-oplossingssjablonen

Amazon SageMaker JumpStart biedt met één klik end-to-end-oplossingen voor veel voorkomende ML-gebruiksscenario's. Verken de volgende use cases voor meer informatie over beschikbare oplossingssjablonen:

De JumpStart-oplossingssjablonen dekken een verscheidenheid aan use-cases, waaronder verschillende oplossingssjablonen worden aangeboden (deze Document Understanding-oplossing bevindt zich onder de use-case "Gegevens uit documenten extraheren en analyseren").

Kies de oplossingssjabloon die het beste bij uw use case past op de JumpStart-bestemmingspagina. Zie voor meer informatie over specifieke oplossingen voor elke gebruikssituatie en het starten van een JumpStart-oplossing Oplossingssjablonen.

Overzicht oplossingen

De volgende afbeelding laat zien hoe u deze oplossing kunt gebruiken met SageMaker-componenten. De SageMaker-trainingstaken worden gebruikt om de verschillende NLP-modellen te trainen en SageMaker-eindpunten worden gebruikt om de modellen in elke fase in te zetten. We gebruiken Amazon eenvoudige opslagservice (Amazon S3) naast SageMaker om de trainingsgegevens en modelartefacten op te slaan, en Amazon Cloud Watch om trainings- en eindpuntuitvoer te loggen.

Open de Document Understanding-oplossing

Navigeer naar de oplossing Document Understanding in JumpStart.

Nu kunnen we enkele van de activa die in deze oplossing zijn opgenomen nader bekijken, te beginnen met de demo-notebook.

Demo-notitieblok

U kunt het demo-notebook gebruiken om voorbeeldgegevens naar reeds geïmplementeerde modeleindpunten te sturen voor de taken voor het samenvatten van documenten en het beantwoorden van vragen. Met het demo-notebook kunt u snel praktijkervaring opdoen door de voorbeeldgegevens op te vragen.

Nadat u de Document Understanding-oplossing hebt gestart, opent u het demo-notebook door te kiezen Eindpunt gebruiken in Notebook.

Laten we dieper ingaan op elk van de vijf belangrijkste notebooks voor deze oplossing.

Voorwaarden

In Amazon SageMaker Studio, zorg ervoor dat u de PyTorch 1.10 Python 3.8 CPU Optimized image/kernel om de notebooks te openen. Training gebruikt vijf ml.g4dn.2xlarge instanties, dus je moet a verhogen verzoek om verhoging van de servicelimiet als uw account hogere limieten vereist voor dit type.

Tekstclassificatie

Tekstclassificatie verwijst naar het classificeren van een invoerzin naar een van de klasselabels van de trainingsdataset. Dit notitieboek laat zien hoe u de JumpStart-API voor tekstclassificatie.

Implementeer en voer inferentie uit op het vooraf getrainde model

Het tekstclassificatiemodel dat we hebben gekozen om te gebruiken, is gebaseerd op een tekstinbedding (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) model van TensorFlow-hub, die vooraf is getraind op datasets van Wikipedia en BookCorpus.

Het model dat beschikbaar is voor implementatie, wordt gemaakt door een binaire classificatielaag aan de uitvoer van het tekstinbeddingsmodel te koppelen en vervolgens het volledige model op de RVS-2 dataset, die bestaat uit positieve en negatieve filmrecensies.

Om inferentie op dit model uit te voeren, moeten we eerst de inferentiecontainer (deploy_image_uri), inferentiescript (deploy_source_uri), en voorgetraind model (base_model_uri). We geven die vervolgens door als parameters om een ​​SageMaker-modelobject te instantiëren, dat we vervolgens kunnen implementeren:

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 "

De volgende code toont onze antwoorden:

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

Verfijn het vooraf getrainde model op een aangepaste dataset

We hebben zojuist lopende gevolgtrekkingen doorlopen op een vooraf getraind BERT-model, dat was afgestemd op de SST-2 gegevensset.

Vervolgens bespreken we hoe u een model kunt verfijnen op een aangepaste gegevensset met een willekeurig aantal klassen. De dataset die we gebruiken voor finetuning is nog steeds de SST-2 gegevensset. U kunt deze dataset vervangen door elke dataset waarin u geïnteresseerd bent.

We halen de training Docker-container, de bron van het trainingsalgoritme en het vooraf getrainde model op:

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

Voor algoritme-specifieke hyperparameters beginnen we met het ophalen van een Python-woordenboek van de trainingshyperparameters die het algoritme accepteert met hun standaardwaarden. U kunt ze overschrijven met aangepaste waarden, zoals weergegeven in de volgende code:

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"

De dataset (SST-2) is opgesplitst in trainings-, validatie- en testsets, waarbij de trainingsset wordt gebruikt om in het model te passen, de validatieset wordt gebruikt om evaluatiestatistieken te berekenen die kunnen worden gebruikt voor HPO, en de testset wordt gebruikt als hold-out-gegevens voor het evalueren van modelprestaties. Vervolgens worden de trein- en validatiegegevensset geüpload naar Amazon S3 en gebruikt om de trainingstaak voor fijnafstemming te starten:

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

Nadat de afstemmingstaak is voltooid, implementeren we het model, voeren we gevolgtrekkingen uit op de hold-out-testdataset en berekenen we evaluatiestatistieken. Omdat het een binaire classificatietaak is, gebruiken we de nauwkeurigheid scoren en F1-score als de evaluatiestatistieken. Een grotere waarde geeft de betere prestatie aan. De volgende schermafbeelding toont onze resultaten.

Verbeter de fijnafstellingsprestaties verder met automatische modelafstemming van SageMaker

In deze stap laten we zien hoe u de modelprestaties verder kunt verbeteren door het model nauwkeurig af te stemmen met SageMaker automatische modelafstelling. Automatische modelafstemming, ook wel hyperparameteroptimalisatie (HPO) genoemd, vindt de beste versie van een model door meerdere trainingstaken uit te voeren op uw dataset met een reeks hyperparameters die u opgeeft. Vervolgens worden de hyperparameterwaarden gekozen die resulteren in een model dat het beste presteert, zoals gemeten door een metriek die u kiest, op de validatiegegevensset.

Eerst stellen we het doel in als de nauwkeurigheidsscore op de validatiegegevens (val_accuracy) en gedefinieerde metrieken voor de afstemmingstaak door de doelmetrieknaam en een reguliere expressie (regex) op te geven. De reguliere expressie wordt gebruikt om overeen te komen met de logboekuitvoer van het algoritme en om de numerieke waarden van metrieken vast te leggen. Vervolgens specificeren we hyperparameterbereiken om de beste hyperparameterwaarden uit te selecteren. We stellen het totaal aantal tuning jobs in op zes en verdelen deze jobs over drie verschillende Amazon Elastic Compute-cloud (Amazon EC2) instanties voor het uitvoeren van parallelle afstemmingstaken. Zie de volgende code:

# 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

We geven die waarden door om een ​​SageMaker Estimator-object te instantiëren, vergelijkbaar met wat we deden in de vorige fijnafstemmingsstap. In plaats van te bellen naar de fit functie van de Estimator object, we passeren de Estimator object in als een parameter voor de HyperparameterTuner constructor en bel de fit functie ervan om afstemmingstaken te starten:

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

Nadat de afstemmingstaken zijn voltooid, implementeren we het model dat de beste evaluatiestatistiekscore geeft op de validatiedataset, voeren we conclusies uit op dezelfde hold-out-testdataset die we in de vorige sectie hebben gedaan en berekenen we evaluatiestatistieken.

De resultaten laten zien dat het model dat is geselecteerd door automatische modelafstemming aanzienlijk beter presteert dan het model dat in de vorige sectie is verfijnd op een hold-out testdataset.

Benoemde entiteitsherkenning

Named Entity Recognition (NER) is het proces van het detecteren en classificeren van benoemde entiteiten in vooraf gedefinieerde categorieën, zoals namen van personen, organisaties, locaties en hoeveelheden. Er zijn veel real-world use-cases voor NER, zoals aanbevelingsengines, het categoriseren en toewijzen van klantenondersteuningstickets aan de juiste afdeling, het extraheren van essentiële informatie uit patiëntrapporten in de gezondheidszorg en inhoudsclassificatie van nieuws en blogs.

Implementeer en voer inferentie uit op het vooraf getrainde model

We zetten de En_core_web_md model uit de ruim bibliotheek. spaCy is een open-source NLP-bibliotheek die voor verschillende taken kan worden gebruikt en heeft ingebouwde methoden voor NER. We gebruiken een AWS PyTorch Deep Learning Container (DLC) met een scriptmodus en installeren de spaCy-bibliotheek als een afhankelijkheid bovenop de container.

Vervolgens wordt een ingangspunt voor het script (argument entry_point.py) is opgegeven en bevat alle code om het En_core_web_md modelleren en gevolgtrekkingen uitvoeren op de gegevens die naar het eindpunt worden verzonden. Tot slot moeten we nog voorzien model_data als het vooraf getrainde model voor inferentie. Omdat de voorgetrainde En_core_web_md model direct wordt gedownload, wat wordt gespecificeerd in het invoerscript, bieden we een leeg archiefbestand. Nadat het eindpunt is geïmplementeerd, kunt u het eindpunt rechtstreeks vanuit de notebook aanroepen met behulp van de SageMaker Python SDK's Predictor. Zie de volgende code:

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

De invoergegevens voor het model zijn een tekstdocument. Het benoemde entiteitsmodel extraheert zelfstandige naamwoorden en benoemde entiteiten in het tekstuele document en classificeert ze in een aantal verschillende typen (zoals mensen, plaatsen en organisaties). De voorbeeldinvoer en -uitvoer worden weergegeven in de volgende code. De start_char parameter geeft de tekenoffset aan voor het begin van de reeks, en end_char geeft het einde van de overspanning aan.

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

Verfijn het vooraf getrainde model op een aangepaste dataset

In deze stap laten we zien hoe u vooraf getrainde taalmodellen voor NER kunt verfijnen op uw eigen dataset. De fijnafstellingsstap werkt de modelparameters bij om de kenmerken van uw eigen gegevens vast te leggen en de nauwkeurigheid te verbeteren. Wij gebruiken de WikiANN (PAN-X) dataset om de DistillBERT-basis, niet ingepakt Transformatormodel van Hugging Face.

De dataset is opgesplitst in trainings-, validatie- en testsets.

Vervolgens specificeren we de hyperparameters van het model en gebruiken we een AWS Hugging Face DLC met een scriptmodus (argument entry_point) om de taak voor fijnafstemming te activeren:

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
)

Nadat de afstemmingstaak is voltooid, implementeren we een eindpunt en vragen we dat eindpunt met de hold-out-testgegevens. Om het eindpunt te bevragen, moet elke tekenreeks worden getokeniseerd in een of meerdere tokens en naar het transformatormodel worden verzonden. Elk token krijgt een voorspelde benoemde entiteitstag. Omdat elke tekenreeks kan worden getokeniseerd in een of meerdere tokens, moeten we de grondwaarheid met de naam entiteitstag van de tekenreeks dupliceren naar alle tokens die eraan zijn gekoppeld. Het meegeleverde notitieboek leidt u door de stappen om dit te bereiken.

Ten slotte gebruiken we de ingebouwde evaluatiestatistieken van Hugging Face vervolg om evaluatiescores op de hold-out testgegevens te berekenen. De gebruikte evaluatiestatistieken zijn algemene precisie, algemene herinnering, algemene F1 en nauwkeurigheid. De volgende schermafbeelding toont onze resultaten.

Verbeter de fijnafstellingsprestaties verder met automatische modelafstemming van SageMaker

Net als bij tekstclassificatie laten we zien hoe u de modelprestaties verder kunt verbeteren door het model nauwkeurig af te stemmen met SageMaker automatische modelafstemming. Om de afstemmingstaak uit te voeren, moeten we een objectieve metriek definiëren die we willen gebruiken voor het evalueren van modelprestaties op de validatiegegevensset (F1-score in dit geval), hyperparameterbereiken om de beste hyperparameterwaarden uit te selecteren, evenals afstemmingstaakconfiguraties zoals maximaal aantal afstemmingstaken en aantal parallelle taken om tegelijk te starten:

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)

Nadat de afstemmingstaken zijn voltooid, implementeren we het model dat de beste evaluatiestatistiekscore geeft op de validatiedataset, voeren we conclusies uit op dezelfde hold-out-testdataset die we in de vorige sectie hebben gedaan en berekenen we evaluatiestatistieken.

We kunnen zien dat het model met HPO aanzienlijk betere prestaties levert voor alle statistieken.

Vraag beantwoorden

Het beantwoorden van vragen is handig wanneer u een grote hoeveelheid tekst wilt doorzoeken op specifieke informatie. Hiermee kan een gebruiker een vraag stellen in natuurlijke taal en een onmiddellijk en kort antwoord krijgen. Vraagantwoordsystemen aangedreven door NLP kunnen worden gebruikt in zoekmachines en interfaces voor telefoongesprekken.

Implementeer en voer inferentie uit op het vooraf getrainde model

Ons vooraf getrainde model is het extractieve vraag-antwoordmodel (EQA). bert-large-uncased-hele-woord-masking-finetuned-squad gebouwd op een Transformer-model van Hugging Face. We gebruiken een AWS PyTorch DLC met een scriptmodus en installeren de transformers bibliotheek als een afhankelijkheid bovenop de container. Net als bij de NER-taak bieden we een leeg archiefbestand in het argument model_data omdat het vooraf getrainde model direct wordt gedownload. Nadat het eindpunt is geïmplementeerd, kunt u het eindpunt rechtstreeks vanuit de notebook aanroepen met behulp van de SageMaker Python SDK's Predictor. Zie de volgende code:

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

Het enige wat we hoeven te doen is een woordenboekobject met twee sleutels te construeren. context is de tekst waaruit we informatie willen ophalen. question is de vraag in natuurlijke taal die specificeert welke informatie we willen extraheren. Wij bellen predict op onze voorspeller, en we zouden een antwoord moeten krijgen van het eindpunt dat de meest waarschijnlijke antwoorden bevat:

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

We hebben het antwoord en we kunnen de meest waarschijnlijke antwoorden afdrukken die uit de voorgaande tekst zijn gehaald. Elk antwoord heeft een betrouwbaarheidsscore die wordt gebruikt voor de rangschikking (maar deze score moet niet worden geïnterpreteerd als een echte waarschijnlijkheid). Naast het letterlijke antwoord krijg je ook de begin- en eindtekenindexen van het antwoord uit de originele context:

print(response['answers'])
[{'score': 0.9793591499328613, 'start': 11, 'end': 15, 'answer': 'thom'}, 
{'score': 0.02019440196454525, 'start': 0, 'end': 15, 'answer': 'my name is thom'}, 
{'score': 4.349117443780415e-05, 'start': 3, 'end': 15, 'answer': 'name is thom'}]

Nu verfijnen we dit model met onze eigen aangepaste dataset om betere resultaten te krijgen.

Verfijn het vooraf getrainde model op een aangepaste dataset

In deze stap laten we zien hoe u vooraf getrainde taalmodellen voor EQA op uw eigen dataset kunt afstemmen. De fijnafstellingsstap werkt de modelparameters bij om de kenmerken van uw eigen gegevens vast te leggen en de nauwkeurigheid te verbeteren. Wij gebruiken de SQuAD2.0 dataset om een ​​tekstinbeddingsmodel te verfijnen bert-base-onomhuld van knuffelend gezicht. Het model dat beschikbaar is voor fijnafstemming koppelt een laag voor het extraheren van antwoorden aan het model voor het insluiten van tekst en initialiseert de laagparameters op willekeurige waarden. De fijnafstemmingsstap verfijnt alle modelparameters om voorspellingsfouten op de invoergegevens te minimaliseren en retourneert het fijnafgestelde model.

Net als bij de tekstclassificatietaak is de dataset (SQuAD2.0) opgesplitst in training, validatie en testset.

Vervolgens specificeren we de hyperparameters van het model en gebruiken we de JumpStart-API om een ​​taak voor fijnafstemming te activeren:

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)

Nadat de afstemmingstaak is voltooid, implementeren we het model, voeren we gevolgtrekkingen uit op de hold-out-testdataset en berekenen we evaluatiestatistieken. De gebruikte evaluatiestatistieken zijn de gemiddelde exacte matchscore en de gemiddelde F1-score. De volgende schermafbeelding toont de resultaten.

Verbeter de fijnafstellingsprestaties verder met automatische modelafstemming van SageMaker

Net als in de vorige paragrafen gebruiken we a HyperparameterTuner bezwaar om afstemmingstaken te starten:

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

Nadat de afstemmingstaken zijn voltooid, implementeren we het model dat de beste evaluatiestatistiekscore geeft op de validatiedataset, voeren we conclusies uit op dezelfde hold-out-testdataset die we in de vorige sectie hebben gedaan en berekenen we evaluatiestatistieken.

We kunnen zien dat het model met HPO significant beter presteert op de hold-out testdata.

Relatie extractie

Relatie-extractie is de taak om semantische relaties uit tekst te extraheren, die meestal tussen twee of meer entiteiten voorkomen. Relatie-extractie speelt een belangrijke rol bij het extraheren van gestructureerde informatie uit ongestructureerde bronnen zoals onbewerkte tekst. In dit notitieblok demonstreren we twee gebruiksvoorbeelden van het extraheren van relaties.

Verfijn het vooraf getrainde model op een aangepaste dataset

We gebruiken een relatie-extractiemodel dat is gebaseerd op een BERT-basis-zonder behuizing model met behulp van transformatoren uit de Hugging Face-transformatoren bibliotheek. Het model voor fijnafstemming koppelt een lineaire classificatielaag die een paar token-inbeddingen neemt die worden uitgevoerd door het tekst-inbeddingsmodel en de laagparameters initialiseert naar willekeurige waarden. De fijnafstemmingsstap verfijnt alle modelparameters om voorspellingsfouten op de invoergegevens te minimaliseren en retourneert het fijnafgestelde model.

De dataset die we het model finetunen is SemEval-2010 Taak 8. Het model dat door fijnafstemming wordt geretourneerd, kan verder worden ingezet voor gevolgtrekkingen.

De dataset bevat trainings-, validatie- en testsets.

We gebruiken de AWS PyTorch DLC met een scriptmodus van de SageMaker Python SDK, waar de transformers bibliotheek wordt geïnstalleerd als de afhankelijkheid bovenop de container. We definiëren de SageMaker PyTorch schatter en een reeks hyperparameters zoals het vooraf getrainde model, leertempo en epoch-nummers om de fijnafstelling uit te voeren. De code voor het verfijnen van het relatie-extractiemodel is gedefinieerd in de entry_point.py. Zie de volgende code:

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

Verbeter de fijnafstellingsprestaties verder met automatische modelafstemming van SageMaker

Net als in de vorige paragrafen gebruiken we a HyperparameterTuner object om te communiceren met SageMaker hyperparameter tuning API's. We kunnen de taak voor hyperparameterafstemming starten door de fit methode:

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

Wanneer de taak voor het afstemmen van hyperparameters is voltooid, voeren we gevolgtrekkingen uit en controleren we de evaluatiescore.

We kunnen zien dat het model met HPO betere prestaties laat zien op de hold-out testdata.

Documentaire samenvatting

Document- of tekstsamenvatting is de taak van het condenseren van grote hoeveelheden tekstgegevens in een kleinere subset van betekenisvolle zinnen die de belangrijkste of meest relevante informatie binnen de originele inhoud vertegenwoordigen. Documentsamenvatting is een handige techniek om belangrijke informatie uit grote hoeveelheden tekstgegevens te destilleren tot enkele zinnen. Tekstsamenvatting wordt in veel gevallen gebruikt, zoals het verwerken van documenten en het extraheren van informatie uit blogs, artikelen en nieuws.

Dit notitieblok demonstreert het implementeren van het documentsamenvattingsmodel T5-basis van het Hugging Face-transformatoren bibliotheek. We testen ook de geïmplementeerde eindpunten met behulp van een tekstartikel en evalueren de resultaten met behulp van de ingebouwde evaluatiemetriek van Hugging Face ROOD.

Net als bij het beantwoorden van vragen en NER-notebooks, gebruiken we de PyTorchModel van de SageMaker Python SDK samen met een entry_point.py script om het T5-basismodel naar een HTTPS-eindpunt te laden. Nadat het eindpunt met succes is geïmplementeerd, kunnen we een tekstartikel naar het eindpunt sturen om een ​​voorspellingsantwoord te krijgen:

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

Vervolgens evalueren en vergelijken we het tekstartikel en het samenvattingsresultaat met behulp van de ROUGE-metriek. Er worden drie evaluatiestatistieken berekend: rougeN, rougeL en rougeLsum. rougeN meet het aantal overeenkomsten n-grams tussen de door het model gegenereerde tekst (samenvattingsresultaat) en a reference (invoertekst). De statistieken rougeL en rougeLsum meet de langste overeenkomende woordreeksen door te zoeken naar de langste gemeenschappelijke subtekenreeksen in de gegenereerde en referentiesamenvattingen. Voor elke statistiek worden betrouwbaarheidsintervallen voor precisie, herinnering en F1-score berekend. Zie de volgende code:

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

Opruimen

Resources die voor deze oplossing zijn gemaakt, kunnen worden verwijderd met behulp van de Alle bronnen verwijderen knop van de SageMaker Studio IDE. Elke notebook biedt ook een opschoonsectie met de code om de eindpunten te verwijderen.

Conclusie

In dit bericht hebben we gedemonstreerd hoe u geavanceerde ML-technieken kunt gebruiken om vijf verschillende NLP-taken op te lossen: documentsamenvatting, tekstclassificatie, vraag en antwoord, herkenning van benoemde entiteiten en extractie van relaties met behulp van Jumpstart. Ga nu aan de slag met Jumpstart!

Over de auteurs

Dr Xin Huang is een toegepast wetenschapper voor de ingebouwde algoritmen van Amazon SageMaker JumpStart en Amazon SageMaker. Hij richt zich op het ontwikkelen van schaalbare algoritmen voor machine learning. Zijn onderzoeksinteresses liggen op het gebied van natuurlijke taalverwerking, verklaarbaar diep leren op tabelgegevens en robuuste analyse van niet-parametrische ruimte-tijdclustering. Hij heeft veel artikelen gepubliceerd in ACL, ICDM, KDD-conferenties en het tijdschrift Royal Statistical Society: Series A.

Vivek Gangasani is Senior Machine Learning Solutions Architect bij Amazon Web Services. Hij helpt startups met het bouwen en operationaliseren van AI/ML-applicaties. Hij richt zich momenteel op het combineren van zijn achtergrond in Containers en Machine Learning om oplossingen te leveren voor MLOps, ML Inference en low-code ML. In zijn vrije tijd probeert hij graag nieuwe restaurants uit en onderzoekt hij opkomende trends in AI en deep learning.

Geremy Cohen is een Solutions Architect bij AWS, waar hij klanten helpt bij het bouwen van geavanceerde, cloudgebaseerde oplossingen. In zijn vrije tijd geniet hij van korte strandwandelingen, het verkennen van de baai met zijn gezin, dingen in huis repareren, dingen in huis kapot maken en barbecuen.

Neelam Koshiya is een enterprise solution architect bij AWS. Haar huidige focus is om zakelijke klanten te helpen met hun reis naar de cloud voor strategische bedrijfsresultaten. In haar vrije tijd houdt ze van lezen en buitenshuis zijn.