Identifiera viktiga insikter från textdokument genom finjustering och HPO med Amazon SageMaker JumpStart

Organisationer över branscher som detaljhandel, bank, finans, hälsovård, tillverkning och utlåning måste ofta hantera stora mängder ostrukturerade textdokument som kommer från olika källor, såsom nyheter, bloggar, produktrecensioner, kundsupportkanaler och sociala medier. Dessa dokument innehåller viktig information som är nyckeln till viktiga affärsbeslut. När en organisation växer blir det en utmaning att extrahera viktig information från dessa dokument. Med utvecklingen av naturlig språkbehandling (NLP) och maskininlärning (ML)-tekniker kan vi upptäcka värdefulla insikter och kopplingar från dessa textdokument snabbt och med hög noggrannhet, och därigenom hjälpa företag att fatta affärsbeslut av hög kvalitet i tid. Fullt hanterade NLP-tjänster har också påskyndat införandet av NLP. Amazon Comprehend är en fullständigt hanterad tjänst som gör att du kan bygga skräddarsydda NLP-modeller som är specifika för dina krav, utan att behöva någon ML-expertis.

I det här inlägget visar vi hur man använder toppmoderna ML-tekniker för att lösa fem olika NLP-uppgifter: dokumentsammanfattning, textklassificering, frågesvar, namngiven enhetsigenkänning och relationsextraktion. För var och en av dessa NLP-uppgifter visar vi hur man använder Amazon SageMaker för att utföra följande åtgärder:

• Distribuera och kör slutledning på en förtränad modell
• Finjustera den förtränade modellen på en ny anpassad datauppsättning
• Förbättra finjusteringsprestandan ytterligare med SageMaker automatisk modelljustering
• Utvärdera modellens prestanda på håll-out testdata med olika utvärderingsmått

Även om vi täcker fem specifika NLP-uppgifter i det här inlägget, kan du använda den här lösningen som en mall för att generalisera finjustering av förtränade modeller med din egen datauppsättning, och därefter köra hyperparameteroptimering för att förbättra noggrannheten.

JumpStart-lösningsmallar

Amazon SageMaker JumpStart tillhandahåller ett klick, end-to-end-lösningar för många vanliga ML-användningsfall. Utforska följande användningsfall för mer information om tillgängliga lösningsmallar:

JumpStart-lösningsmallarna täcker en mängd olika användningsfall, under vilka flera olika lösningsmallar erbjuds (denna Document Understanding-lösning finns under användningsfallet "Extrahera och analysera data från dokument").

Välj den lösningsmall som bäst passar ditt användningsfall från JumpStart-målsidan. För mer information om specifika lösningar under varje användningsfall och hur man startar en JumpStart-lösning, se Lösningsmallar.

Lösningsöversikt

Följande bild visar hur du kan använda den här lösningen med SageMaker-komponenter. SageMakers utbildningsjobb används för att träna de olika NLP-modellerna, och SageMaker-slutpunkter används för att distribuera modellerna i varje steg. Vi använder Amazon enkel lagringstjänst (Amazon S3) tillsammans med SageMaker för att lagra träningsdata och modellartefakter, och amazoncloudwatch för att logga tränings- och slutpunktsutgångar.

Öppna lösningen Document Understanding

Navigera till Document Understanding-lösningen i JumpStart.

Nu kan vi ta en närmare titt på några av tillgångarna som ingår i den här lösningen, med början med demo-anteckningsboken.

Demo anteckningsbok

Du kan använda demonstrationsanteckningsboken för att skicka exempeldata till redan utplacerade modellslutpunkter för uppgifterna för dokumentsammanfattning och frågesvar. Demo-anteckningsboken låter dig snabbt få praktisk erfarenhet genom att fråga efter exempeldata.

När du har startat Document Understanding-lösningen öppnar du demo-anteckningsboken genom att välja Använd Endpoint i Notebook.

Låt oss dyka djupare in i var och en av de fem viktigaste bärbara datorerna för den här lösningen.

Förutsättningar

In Amazon SageMaker Studio, se till att du använder PyTorch 1.10 Python 3.8 CPU Optimized bild/kärna för att öppna anteckningsböckerna. Träning använder fem ml.g4dn.2xlarge instanser, så du bör höja en begäran om höjning av tjänstegränsen om ditt konto kräver ökade gränser för denna typ.

Textklassificering

Textklassificering hänvisar till att klassificera en inmatad mening till en av klassetiketterna i träningsdatauppsättningen. Den här anteckningsboken visar hur man använder JumpStart API för textklassificering.

Distribuera och kör slutledning på den förtränade modellen

Textklassificeringsmodellen vi har valt att använda bygger på en textinbäddning (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) modell från TensorFlow Hub, som är förtränad på Wikipedia och BookCorpus dataset.

Modellen som är tillgänglig för distribution skapas genom att bifoga ett binärt klassificeringsskikt till utdata från textinbäddningsmodellen och sedan finjustera hela modellen på SST-2 datauppsättning, som består av positiva och negativa filmrecensioner.

För att köra inferens på den här modellen måste vi först ladda ner inferensbehållaren (deploy_image_uri), slutledningsskript (deploy_source_uri), och förutbildad modell (base_model_uri). Vi skickar sedan dessa som parametrar för att instansiera ett SageMaker-modellobjekt, som vi sedan kan distribuera:

model = Model(
    image_uri=deploy_image_uri,
    source_dir=deploy_source_uri,
    model_data=base_model_uri,
    entry_point="inference.py",
    role=aws_role,
    predictor_cls=Predictor,
    name=endpoint_name_tc,
)
# deploy the Model.
base_model_predictor = model.deploy(
    initial_instance_count=1,
    instance_type=inference_instance_type,
    endpoint_name=endpoint_name_tc,
)

text1 = "astonishing ... ( frames ) profound ethical and philosophical questions in the form of dazzling pop entertainment" 
text2 = "simply stupid , irrelevant and deeply , truly , bottomlessly cynical "

Följande kod visar våra svar:

Inference:
Input text: 'astonishing ... ( frames ) profound ethical and philosophical questions in the form of dazzling pop entertainment'
Model prediction: [0.000452966779, 0.999547064]
Labels: [0, 1]
Predicted Label: 1 # value 0 means negative sentiment and value 1 means positive sentiment

Inference:
Input text: 'simply stupid , irrelevant and deeply , truly , bottomlessly cynical '
Model prediction: [0.998723, 0.00127695734]
Labels: [0, 1]
Predicted Label: 0

Finjustera den förtränade modellen på en anpassad datauppsättning

Vi gick precis igenom löpande slutledning på en förtränad BERT-modell, som var finjusterad på SST-2 datasätt.

Därefter diskuterar vi hur man finjusterar en modell på en anpassad datauppsättning med valfritt antal klasser. Datauppsättningen vi använder för finjustering är fortfarande den SST-2 dataset. Du kan ersätta denna datauppsättning med vilken datauppsättning som helst som du är intresserad av.

Vi hämtar utbildningsdockningsbehållaren, träningsalgoritmkällan och förtränad modell:

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

För algoritmspecifika hyperparametrar börjar vi med att hämta en Python-ordbok över de träningshyperparametrar som algoritmen accepterar med sina standardvärden. Du kan åsidosätta dem med anpassade värden, som visas i följande kod:

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"

Datauppsättningen (SST-2) är uppdelad i utbildnings-, validerings- och testuppsättningar, där träningsuppsättningen används för att passa modellen, valideringsuppsättningen används för att beräkna utvärderingsmått som kan användas för HPO, och testuppsättningen används som uthållningsdata för att utvärdera modellens prestanda. Därefter laddas tåg- och valideringsdataset upp till Amazon S3 och används för att lansera finjusterande träningsjobb:

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

När finjusteringsjobbet är slutfört distribuerar vi modellen, kör slutledning på den hållna testdatauppsättningen och beräknar utvärderingsstatistik. Eftersom det är en binär klassificeringsuppgift använder vi noggrannhetspoäng och F1-poäng som utvärderingsmått. Ett högre värde indikerar bättre prestanda. Följande skärmdump visar våra resultat.

Förbättra finjusteringsprestandan ytterligare med SageMaker automatisk modellinställning

I det här steget visar vi hur du ytterligare kan förbättra modellens prestanda genom att finjustera modellen med SageMaker automatisk modellinställning. Automatisk modellinställning, även känd som hyperparameteroptimering (HPO), hittar den bästa versionen av en modell genom att köra flera träningsjobb på din datauppsättning med en rad hyperparametrar som du anger. Den väljer sedan hyperparametervärdena som resulterar i en modell som presterar bäst, mätt med ett mått som du väljer, på valideringsdataset.

Först sätter vi målet som noggrannhetspoäng på valideringsdata (val_accuracy) och definierade mätvärden för inställningsjobbet genom att ange det objektiva måttets namn och ett reguljärt uttryck (regex). Det reguljära uttrycket används för att matcha algoritmens loggutgång och fånga de numeriska värdena för mätvärden. Därefter anger vi hyperparameterintervall för att välja de bästa hyperparametervärdena från. Vi sätter det totala antalet trimjobb till sex och fördelar dessa jobb på tre olika Amazon Elastic Compute Cloud (Amazon EC2)-instanser för att köra parallella inställningsjobb. Se följande kod:

# Define objective metric per framework, based on which the best model will be selected.
metric_definitions_per_model = {
    "tensorflow": {
        "metrics": [{"Name": "val_accuracy", "Regex": "val_accuracy: ([0-9.]+)"}],
        "type": "Maximize",
    }
}

# You can select from the hyperparameters supported by the model, and configure ranges of values to be searched for training the optimal model.(https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-define-ranges.html)
hyperparameter_ranges = {
    "adam-learning-rate": ContinuousParameter(0.00001, 0.01, scaling_type="Logarithmic")
}

# Increase the total number of training jobs run by AMT, for increased accuracy (and training time).
max_jobs = 6
# Change parallel training jobs run by AMT to reduce total training time, constrained by your account limits.
# if max_jobs=max_parallel_jobs then Bayesian search turns to Random.
max_parallel_jobs = 3

Vi skickar dessa värden för att instansiera ett SageMaker Estimator-objekt, liknande det vi gjorde i det föregående finjusteringssteget. Istället för att ringa fit funktion av Estimator objekt, vi passerar Estimator objekt i som en parameter till HyperparameterTuner konstruktör och ring fit funktion för att starta trimningsjobb:

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

När trimningsjobben är klara, distribuerar vi modellen som ger det bästa utvärderingsmåttet på valideringsdatasetet, utför slutsatser på samma hold-out-testdataset som vi gjorde i föregående avsnitt och beräknar utvärderingsmått.

Resultaten visar att den modell som valts genom automatisk modellinställning avsevärt överträffar den modell som finjusterats i föregående avsnitt på en hold-out-testdatauppsättning.

Namngivet enhet erkännande

Namngivna enheter (NER) är processen att upptäcka och klassificera namngivna enheter i fördefinierade kategorier, såsom namn på personer, organisationer, platser och kvantiteter. Det finns många verkliga användningsfall för NER, till exempel rekommendationsmotorer, kategorisering och tilldelning av kundsupportbiljetter till rätt avdelning, extrahering av viktig information från patientrapporter inom vården och innehållsklassificering från nyheter och bloggar.

Distribuera och kör slutledning på den förtränade modellen

Vi distribuerar En_core_web_md modell från rymd bibliotek. spaCy är ett NLP-bibliotek med öppen källkod som kan användas för olika uppgifter, och har inbyggda metoder för NER. Vi använder en AWS PyTorch Deep Learning Container (DLC) med ett skriptläge och installerar spaCy-biblioteket som ett beroende ovanpå behållaren.

Därefter en ingångspunkt för skriptet (argument entry_point.py) specificeras och innehåller all kod för att ladda ner och ladda En_core_web_md modellera och utföra slutledning av data som skickas till endpoint. Slutligen måste vi fortfarande ge model_data som den förtränade modellen för slutledning. Eftersom de förutbildade En_core_web_md modellen laddas ner i farten, vilket anges i inmatningsskriptet, tillhandahåller vi en tom arkivfil. Efter att slutpunkten har distribuerats kan du anropa slutpunkten direkt från anteckningsboken med SageMaker Python SDK:s Predictor. Se följande kod:

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

Indata för modellen är ett textdokument. Den namngivna enhetsmodellen extraherar substantivbitar och namngivna enheter i textdokumentet och klassificerar dem i ett antal olika typer (som personer, platser och organisationer). Exempel på ingång och utdata visas i följande kod. De start_char parameter indikerar teckenoffset för början av intervallet, och end_char indikerar slutet av intervallet.

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

Finjustera den förtränade modellen på en anpassad datauppsättning

I det här steget visar vi hur man finjusterar en förtränad språkmodell för NER på din egen datauppsättning. Finjusteringssteget uppdaterar modellparametrarna för att fånga egenskaperna hos dina egna data och förbättra noggrannheten. Vi använder WikiANN (PAN-X) dataset för att finjustera DistilBERT-bas-ohölje Transformatormodell från Hugging Face.

Datauppsättningen är uppdelad i utbildnings-, validerings- och testuppsättningar.

Därefter anger vi hyperparametrarna för modellen och använder en AWS Hugging Face DLC med ett skriptläge (argument entry_point) för att utlösa finjusteringsjobbet:

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
)

När finjusteringsjobbet är slutfört distribuerar vi en slutpunkt och frågar efter den slutpunkten med testdata som håller ut. För att fråga efter slutpunkten måste varje textsträng tokeniseras till en eller flera tokens och skickas till transformatormodellen. Varje token får en förutspådd namngiven entitetstagg. Eftersom varje textsträng kan tokeniseras till en eller flera tokens, måste vi duplicera entitetstaggen med namnet ground truth för strängen till alla tokens som är associerade med den. Den medföljande anteckningsboken leder dig genom stegen för att uppnå detta.

Slutligen använder vi Hugging Face inbyggda utvärderingsmått seqeval för att beräkna utvärderingspoäng på håll-out-testdata. De utvärderingsmått som används är övergripande precision, övergripande återkallelse, övergripande F1 och noggrannhet. Följande skärmdump visar våra resultat.

Förbättra finjusteringsprestandan ytterligare med SageMaker automatisk modellinställning

I likhet med textklassificering visar vi hur du ytterligare kan förbättra modellens prestanda genom att finjustera modellen med SageMaker automatisk modellinställning. För att köra inställningsjobbet behöver vi definiera ett objektivt mått som vi vill använda för att utvärdera modellprestanda på valideringsdataset (F1-poäng i det här fallet), hyperparameterintervall för att välja de bästa hyperparametervärdena från, samt justera jobbkonfigurationer som t.ex. maximalt antal trimjobb och antal parallella jobb att lansera åt gången:

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)

När trimningsjobben är klara, distribuerar vi modellen som ger det bästa utvärderingsmåttet på valideringsdatasetet, utför slutsatser på samma hold-out-testdataset som vi gjorde i föregående avsnitt och beräknar utvärderingsmått.

Vi kan se att modellen med HPO uppnår betydligt bättre prestanda över alla mätvärden.

Frågesvar

Frågesvar är användbart när du vill fråga en stor mängd text för specifik information. Det låter en användare uttrycka en fråga på naturligt språk och få ett omedelbart och kort svar. Frågesvarssystem som drivs av NLP kan användas i sökmotorer och gränssnitt för telefonsamtal.

Distribuera och kör slutledning på den förtränade modellen

Vår förutbildade modell är den extraktiva frågesvarsmodellen (EQA). bert-stora-uncased-hela-ord-maskering-finstämda-squad byggd på en Transformer-modell från Hugging Face. Vi använder en AWS PyTorch DLC med ett skriptläge och installerar transformatorer bibliotek som ett beroende ovanpå behållaren. I likhet med NER-uppgiften tillhandahåller vi en tom arkivfil i argumentet model_data eftersom den förtränade modellen laddas ner i farten. Efter att slutpunkten har distribuerats kan du anropa slutpunkten direkt från anteckningsboken med SageMaker Python SDK:s Predictor. Se följande kod:

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

Allt vi behöver göra är att konstruera ett ordboksobjekt med två nycklar. context är texten som vi vill hämta information från. question är den naturliga språkfrågan som anger vilken information vi är intresserade av att extrahera. Vi ringer predict på vår prediktor, och vi bör få ett svar från den slutpunkt som innehåller de mest sannolika svaren:

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

Vi har svaret, och vi kan skriva ut de mest sannolika svaren som har hämtats från föregående text. Varje svar har en konfidenspoäng som används för rankning (men denna poäng ska inte tolkas som en sann sannolikhet). Förutom det ordagranta svaret får du också start- och slutteckenindex för svaret från det ursprungliga sammanhanget:

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 finjusterar vi den här modellen med vår egen anpassade datauppsättning för att få bättre resultat.

Finjustera den förtränade modellen på en anpassad datauppsättning

I det här steget visar vi hur du finjusterar en förtränad språkmodell för EQA på din egen datauppsättning. Finjusteringssteget uppdaterar modellparametrarna för att fånga egenskaperna hos dina egna data och förbättra noggrannheten. Vi använder SQuAD2.0 datauppsättning för att finjustera en textinbäddningsmodell bert-bas-okapslad från Hugging Face. Modellen som är tillgänglig för finjustering kopplar ett svarsextraherande lager till textinbäddningsmodellen och initierar lagerparametrarna till slumpmässiga värden. Finjusteringssteget finjusterar alla modellparametrar för att minimera prediktionsfel på indata och returnerar den finjusterade modellen.

I likhet med textklassificeringsuppgiften är datasetet (SQuAD2.0) uppdelat i träning, validering och testuppsättning.

Därefter anger vi modellens hyperparametrar och använder JumpStart API för att utlösa ett finjusteringsjobb:

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

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

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

När finjusteringsjobbet är slutfört distribuerar vi modellen, kör slutledning på den hållna testdatauppsättningen och beräknar utvärderingsstatistik. De utvärderingsmått som används är den genomsnittliga exakta matchningspoängen och den genomsnittliga F1-poängen. Följande skärmdump visar resultaten.

Förbättra finjusteringsprestandan ytterligare med SageMaker automatisk modellinställning

I likhet med föregående avsnitt använder vi en HyperparameterTuner invända mot att starta trimjobb:

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

När trimningsjobben är klara, distribuerar vi modellen som ger det bästa utvärderingsmåttet på valideringsdatasetet, utför slutsatser på samma hold-out-testdataset som vi gjorde i föregående avsnitt och beräknar utvärderingsmått.

Vi kan se att modellen med HPO visar en betydligt bättre prestanda på uthållningstestdata.

Relationsutvinning

Relationsextraktion är uppgiften att extrahera semantiska relationer från text, som vanligtvis förekommer mellan två eller flera entiteter. Relationsextraktion spelar en viktig roll för att extrahera strukturerad information från ostrukturerade källor som råtext. I den här anteckningsboken visar vi två användningsfall av relationsextraktion.

Finjustera den förtränade modellen på en anpassad datauppsättning

Vi använder en relationsextraktionsmodell byggd på en BERT-bas utan hölje modell med transformatorer från Kramande ansikts transformatorer bibliotek. Modellen för finjustering bifogar ett linjärt klassificeringsskikt som tar ett par tokeninbäddningar som matas ut av textinbäddningsmodellen och initierar lagerparametrarna till slumpmässiga värden. Finjusteringssteget finjusterar alla modellparametrar för att minimera prediktionsfel på indata och returnerar den finjusterade modellen.

Datauppsättningen vi finjusterar modellen är SemEval-2010 Uppgift 8. Modellen som returneras genom finjustering kan vidareutvecklas för slutledning.

Datauppsättningen innehåller utbildning, validering och testuppsättningar.

Vi använder AWS PyTorch DLC med ett skriptläge från SageMaker Python SDK, där transformers biblioteket är installerat som beroende på toppen av behållaren. Vi definierar SageMaker PyTorch estimator och en uppsättning hyperparametrar såsom den förtränade modellen, inlärningshastigheten och epoktal för att utföra finjusteringen. Koden för att finjustera relationsextraktionsmodellen definieras i entry_point.py. Se följande kod:

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

Förbättra finjusteringsprestandan ytterligare med SageMaker automatisk modellinställning

I likhet med föregående avsnitt använder vi en HyperparameterTuner objekt för att interagera med SageMaker hyperparameter tuning API:er. Vi kan starta hyperparameterjusteringsjobbet genom att anropa 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/",
})

När hyperparameterinställningsjobbet är klart utför vi slutledning och kontrollerar utvärderingspoängen.

Vi kan se att modellen med HPO visar bättre prestanda på uthållningstestdata.

Dokumentsammanfattning

Dokument- eller textsammanfattning är uppgiften att kondensera stora mängder textdata till en mindre delmängd av meningsfulla meningar som representerar den viktigaste eller mest relevanta informationen i det ursprungliga innehållet. Dokumentsammanfattning är en användbar teknik för att destillera viktig information från stora mängder textdata till några få meningar. Textsammanfattning används i många användningsfall, såsom dokumentbehandling och extrahering av information från bloggar, artiklar och nyheter.

Den här anteckningsboken visar hur man använder dokumentsammanfattningsmodellen T5-bas från Kramande ansikts transformatorer bibliotek. Vi testar också de implementerade slutpunkterna med hjälp av en textartikel och utvärderar resultaten med hjälp av det inbyggda utvärderingsmåttet Hugging Face RÖD.

I likhet med frågesvar och NER-anteckningsböcker använder vi PyTorchModel från SageMaker Python SDK tillsammans med en entry_point.py skript för att ladda T5-basmodellen till en HTTPS-slutpunkt. När slutpunkten har distribuerats framgångsrikt kan vi skicka en textartikel till slutpunkten för att få ett förutsägelsesvar:

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

Därefter utvärderar och jämför vi textartikeln och sammanfattningsresultatet med hjälp av ROUGE-måttet. Tre utvärderingsmått beräknas: rougeN, rougeLoch rougeLsum. rougeN mäter antalet matchningar n-grams mellan den modellgenererade texten (sammanfattningsresultat) och en reference (mata in text). Måtten rougeL och rougeLsum mät de längsta matchande sekvenserna av ord genom att leta efter de längsta vanliga delsträngarna i de genererade sammanfattningarna och referenssammanfattningarna. För varje mätvärde beräknas konfidensintervall för precision, återkallelse och F1-poäng. Se följande kod:

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

Städa upp

Resurser som skapats för denna lösning kan raderas med hjälp av Ta bort alla resurser från SageMaker Studio IDE. Varje anteckningsbok innehåller också en rensningssektion med koden för att ta bort slutpunkterna.

Slutsats

I det här inlägget demonstrerade vi hur man använder toppmoderna ML-tekniker för att lösa fem olika NLP-uppgifter: dokumentsammanfattning, textklassificering, fråga och svar, namngiven enhetsigenkänning och relationsextraktion med Jumpstart. Kom igång med Jumpstart nu!

Om författarna

Dr Xin Huang är en tillämpad forskare för Amazon SageMaker JumpStart och Amazon SageMaker inbyggda algoritmer. Han fokuserar på att utveckla skalbara maskininlärningsalgoritmer. Hans forskningsintressen är inom området naturlig språkbehandling, förklarlig djupinlärning på tabelldata och robust analys av icke-parametrisk rum-tid-klustring. Han har publicerat många artiklar i ACL, ICDM, KDD-konferenser och Royal Statistical Society: Series A journal.

Vivek Gangasani är Senior Machine Learning Solutions Architect på Amazon Web Services. Han hjälper startups att bygga och operationalisera AI/ML-applikationer. Han fokuserar för närvarande på att kombinera sin bakgrund inom Containers och Machine Learning för att leverera lösningar på MLOps, ML Inference och low-code ML. På fritiden tycker han om att prova nya restauranger och utforska nya trender inom AI och djupinlärning.

Geremy Cohen är en lösningsarkitekt med AWS där han hjälper kunderna att bygga avancerade molnbaserade lösningar. På fritiden njuter han av korta promenader på stranden, utforskar vikområdet med sin familj, fixar saker runt huset, bryter saker runt huset och grillar.

Neelam Koshiya är företagslösningsarkitekt på AWS. Hennes nuvarande fokus är att hjälpa företagskunder med deras molnadoptionsresa för strategiska affärsresultat. På fritiden tycker hon om att läsa och vara utomhus.