Identifica gli insight chiave dai documenti di testo attraverso il fine tuning e l'HPO con Amazon SageMaker JumpStart

Le organizzazioni di vari settori come vendita al dettaglio, banche, finanza, assistenza sanitaria, produzione e prestiti spesso devono gestire grandi quantità di documenti di testo non strutturati provenienti da varie fonti, come notizie, blog, recensioni di prodotti, canali di assistenza clienti e social media. Questi documenti contengono informazioni critiche che sono fondamentali per prendere importanti decisioni aziendali. Man mano che un'organizzazione cresce, diventa una sfida estrarre informazioni critiche da questi documenti. Con il progresso delle tecniche di elaborazione del linguaggio naturale (NLP) e di apprendimento automatico (ML), possiamo scoprire preziose informazioni e connessioni da questi documenti testuali in modo rapido e con elevata precisione, aiutando così le aziende a prendere decisioni aziendali di qualità in tempo. Anche i servizi di PNL completamente gestiti hanno accelerato l'adozione della PNL. Amazon Comprehend è un servizio completamente gestito che ti consente di creare modelli NLP personalizzati specifici per le tue esigenze, senza la necessità di alcuna competenza ML.

In questo post, dimostriamo come utilizzare tecniche ML all'avanguardia per risolvere cinque diverse attività di PNL: riepilogo dei documenti, classificazione del testo, risposta alle domande, riconoscimento di entità denominate ed estrazione delle relazioni. Per ciascuna di queste attività di PNL, dimostriamo come utilizzare Amazon Sage Maker per eseguire le seguenti azioni:

• Distribuisci ed esegui l'inferenza su un modello preaddestrato
• Ottimizza il modello pre-addestrato su un nuovo set di dati personalizzato
• Migliorare ulteriormente le prestazioni di messa a punto con Ottimizzazione automatica del modello di SageMaker
• Valuta le prestazioni del modello sui dati del test di controllo con varie metriche di valutazione

Sebbene in questo post trattiamo cinque attività NLP specifiche, puoi utilizzare questa soluzione come modello per generalizzare la messa a punto di modelli pre-addestrati con il tuo set di dati e successivamente eseguire l'ottimizzazione dell'iperparametro per migliorare la precisione.

Modelli di soluzione JumpStart

JumpStart di Amazon SageMaker fornisce soluzioni end-to-end con un clic per molti casi d'uso comuni di ML. Esplora i seguenti casi d'uso per ulteriori informazioni sui modelli di soluzione disponibili:

I modelli di soluzione JumpStart coprono una varietà di casi d'uso, in ciascuno dei quali vengono offerti diversi modelli di soluzione (questa soluzione Document Understanding rientra nel caso d'uso "Estrai e analizza i dati dai documenti").

Scegli il modello di soluzione che meglio si adatta al tuo caso d'uso dalla pagina di destinazione di JumpStart. Per ulteriori informazioni su soluzioni specifiche in ogni caso d'uso e su come avviare una soluzione JumpStart, vedere Modelli di soluzione.

Panoramica della soluzione

L'immagine seguente mostra come utilizzare questa soluzione con i componenti SageMaker. I lavori di addestramento SageMaker vengono utilizzati per addestrare i vari modelli NLP e gli endpoint SageMaker vengono utilizzati per distribuire i modelli in ogni fase. Noi usiamo Servizio di archiviazione semplice Amazon (Amazon S3) insieme a SageMaker per archiviare i dati di addestramento e gli artefatti del modello e Amazon Cloud Watch per registrare l'addestramento e gli output dell'endpoint.

Apri la soluzione Document Understanding

Passare alla soluzione Document Understanding in JumpStart.

Ora possiamo dare un'occhiata più da vicino ad alcune delle risorse incluse in questa soluzione, a partire dal notebook demo.

Quaderno dimostrativo

Puoi utilizzare il notebook demo per inviare dati di esempio agli endpoint del modello già distribuiti per le attività di riepilogo dei documenti e di risposta alle domande. Il taccuino dimostrativo ti consente di acquisire rapidamente esperienza pratica eseguendo query sui dati di esempio.

Dopo aver avviato la soluzione Document Understanding, apri il taccuino dimostrativo scegliendo Usa l'endpoint nel blocco appunti.

Approfondiamo ciascuno dei cinque notebook principali per questa soluzione.

Prerequisiti

In Amazon Sage Maker Studio, assicurati di utilizzare il PyTorch 1.10 Python 3.8 CPU Optimized image/kernel per aprire i notebook. L'addestramento utilizza cinque istanze ml.g4dn.2xlarge, quindi dovresti aumentare a richiesta di aumento del limite di servizio se il tuo account richiede limiti maggiori per questo tipo.

Classificazione del testo

La classificazione del testo si riferisce alla classificazione di una frase di input in una delle etichette di classe del set di dati di addestramento. Questo taccuino dimostra come utilizzare il API JumpStart per la classificazione del testo.

Distribuisci ed esegui l'inferenza sul modello preaddestrato

Il modello di classificazione del testo che abbiamo scelto di utilizzare si basa su un incorporamento del testo (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) modello da Hub TensorFlow, che è preaddestrato sui set di dati di Wikipedia e BookCorpus.

Il modello disponibile per la distribuzione viene creato allegando un livello di classificazione binaria all'output del modello di incorporamento del testo, quindi perfezionando l'intero modello sul SST-2 set di dati, che comprende recensioni di film positive e negative.

Per eseguire l'inferenza su questo modello, dobbiamo prima scaricare il contenitore di inferenza (deploy_image_uri), script di inferenza (deploy_source_uri) e modello pre-addestrato (base_model_uri). Quindi li passiamo come parametri per creare un'istanza di un oggetto modello SageMaker, che possiamo quindi distribuire:

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 "

Il codice seguente mostra le nostre risposte:

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

Ottimizza il modello pre-addestrato su un set di dati personalizzato

Abbiamo appena esaminato l'inferenza in esecuzione su un modello BERT pre-addestrato, che è stato messo a punto su SST-2 set di dati.

Successivamente, discuteremo come mettere a punto un modello su un set di dati personalizzato con qualsiasi numero di classi. Il set di dati che utilizziamo per la messa a punto è ancora il SST-2 insieme di dati. Puoi sostituire questo set di dati con qualsiasi set di dati che ti interessa.

Recuperiamo il contenitore Docker di addestramento, l'origine dell'algoritmo di addestramento e il modello pre-addestrato:

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

Per gli iperparametri specifici dell'algoritmo, iniziamo recuperando un dizionario Python degli iperparametri di addestramento che l'algoritmo accetta con i loro valori predefiniti. Puoi sovrascriverli con valori personalizzati, come mostrato nel codice seguente:

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"

Il set di dati (SST-2) è suddiviso in set di addestramento, convalida e test, in cui il set di addestramento viene utilizzato per adattare il modello, il set di convalida viene utilizzato per calcolare le metriche di valutazione che possono essere utilizzate per HPO e il set di test viene utilizzato come dati di controllo per la valutazione delle prestazioni del modello. Successivamente, il set di dati di addestramento e convalida viene caricato su Amazon S3 e utilizzato per avviare il lavoro di addestramento di fine tuning:

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

Una volta completato il lavoro di fine tuning, distribuiamo il modello, eseguiamo l'inferenza sul set di dati di test di hold-out e calcoliamo le metriche di valutazione. Poiché si tratta di un'attività di classificazione binaria, utilizziamo il file punteggio di precisione ed punteggio F1 come metriche di valutazione. Un valore maggiore indica le prestazioni migliori. Lo screenshot seguente mostra i nostri risultati.

Migliora ulteriormente le prestazioni di messa a punto con la messa a punto automatica del modello SageMaker

In questa fase, dimostriamo come migliorare ulteriormente le prestazioni del modello ottimizzando il modello con l'ottimizzazione automatica del modello SageMaker. L'ottimizzazione automatica del modello, nota anche come ottimizzazione dell'iperparametro (HPO), trova la versione migliore di un modello eseguendo più processi di addestramento sul set di dati con una gamma di iperparametri specificata. Quindi sceglie i valori dell'iperparametro che risultano in un modello che offre le prestazioni migliori, misurate da una metrica scelta, sul set di dati di convalida.

Innanzitutto, impostiamo l'obiettivo come punteggio di accuratezza sui dati di convalida (val_accuracy) e le metriche definite per il processo di ottimizzazione specificando il nome della metrica obiettivo e un'espressione regolare (regex). L'espressione regolare viene utilizzata per abbinare l'output del log dell'algoritmo e acquisire i valori numerici delle metriche. Successivamente, specifichiamo gli intervalli di iperparametri da cui selezionare i migliori valori di iperparametri. Impostiamo il numero totale di lavori di ottimizzazione su sei e distribuiamo questi lavori su tre diversi Cloud di calcolo elastico di Amazon (Amazon EC2) per l'esecuzione di processi di ottimizzazione paralleli. Vedere il seguente codice:

# 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

Passiamo questi valori per istanziare un oggetto SageMaker Estimator, in modo simile a quanto fatto nella precedente fase di fine tuning. Invece di chiamare il fit funzione del Estimator oggetto, passiamo il Estimator oggetto come parametro per il Sintonizzatore iperparametri costruttore e chiamare il fit funzione di esso per avviare i lavori di ottimizzazione:

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

Dopo che i lavori di ottimizzazione sono stati completati, distribuiamo il modello che fornisce il miglior punteggio della metrica di valutazione sul set di dati di convalida, eseguiamo l'inferenza sullo stesso set di dati di test di hold-out che abbiamo fatto nella sezione precedente e calcoliamo le metriche di valutazione.

I risultati mostrano che il modello selezionato dall'ottimizzazione automatica del modello supera in modo significativo il modello ottimizzato nella sezione precedente su un set di dati di test di controllo.

Riconoscimento dell'entità denominata

Il riconoscimento di entità denominate (NER) è il processo di rilevamento e classificazione di entità denominate in categorie predefinite, come nomi di persone, organizzazioni, luoghi e quantità. Esistono molti casi d'uso reali per NER, come i motori di raccomandazione, la categorizzazione e l'assegnazione dei ticket di assistenza clienti al reparto giusto, l'estrazione di informazioni essenziali dalle segnalazioni dei pazienti nel settore sanitario e la classificazione dei contenuti da notizie e blog.

Distribuisci ed esegui l'inferenza sul modello preaddestrato

Distribuiamo il En_core_web_md modello dal spacy biblioteca. spaCy è una libreria NLP open source che può essere utilizzata per varie attività e dispone di metodi integrati per NER. Usiamo un AWS PyTorch Deep Learning Container (DLC) con una modalità script e installiamo la libreria spaCy come dipendenza sopra il container.

Successivamente, un punto di ingresso per lo script (argument entry_point.py) è specificato, contenente tutto il codice per scaricare e caricare il file En_core_web_md modellare ed eseguire l'inferenza sui dati inviati all'endpoint. Infine, dobbiamo ancora fornire model_data come modello pre-addestrato per l'inferenza. Perché il pre-addestrato En_core_web_md model viene scaricato al volo, che è specificato nello script di ingresso, forniamo un file di archivio vuoto. Dopo che l'endpoint è stato distribuito, puoi richiamare l'endpoint direttamente dal notebook utilizzando SageMaker Python SDK Predictor. Vedi il seguente codice:

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

I dati di input per il modello sono un documento testuale. Il modello di entità denominata estrae blocchi di nomi ed entità denominate nel documento testuale e le classifica in un numero di tipi diversi (come persone, luoghi e organizzazioni). L'input e l'output di esempio sono mostrati nel codice seguente. Il start_char Il parametro indica l'offset del carattere per l'inizio dell'estensione e end_char indica la fine dell'intervallo.

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

Ottimizza il modello pre-addestrato su un set di dati personalizzato

In questa fase, dimostriamo come mettere a punto un modello linguistico pre-addestrato per NER sul tuo set di dati. La fase di fine tuning aggiorna i parametri del modello per acquisire le caratteristiche dei propri dati e migliorare la precisione. Noi usiamo il WikiANN (PAN-X) set di dati per ottimizzare il file DistilBERT-base-senza custodia Modello trasformatore di Hugging Face.

Il set di dati è suddiviso in set di addestramento, convalida e test.

Successivamente, specifichiamo gli iperparametri del modello e utilizziamo un DLC AWS Hugging Face con una modalità script (argomento entry_point) per attivare il lavoro di fine tuning:

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
)

Una volta completato il lavoro di fine tuning, distribuiamo un endpoint e interroghiamo tale endpoint con i dati del test di controllo. Per interrogare l'endpoint, ogni stringa di testo deve essere tokenizzata in uno o più token e inviata al modello di trasformatore. Ogni token ottiene un tag di entità denominato previsto. Poiché ogni stringa di testo può essere tokenizzata in uno o più token, è necessario duplicare il tag di entità denominato Ground Truth della stringa in tutti i token ad esso associati. Il taccuino fornito ti guida attraverso i passaggi per raggiungere questo obiettivo.

Infine, utilizziamo le metriche di valutazione integrate di Hugging Face successivo per calcolare i punteggi di valutazione sui dati del test di controllo. Le metriche di valutazione utilizzate sono la precisione complessiva, il richiamo complessivo, l'F1 complessivo e l'accuratezza. Lo screenshot seguente mostra i nostri risultati.

Migliora ulteriormente le prestazioni di messa a punto con la messa a punto automatica del modello SageMaker

Analogamente alla classificazione del testo, dimostriamo come migliorare ulteriormente le prestazioni del modello perfezionando il modello con l'ottimizzazione automatica del modello di SageMaker. Per eseguire il lavoro di ottimizzazione, dobbiamo definire una metrica oggettiva che vogliamo utilizzare per valutare le prestazioni del modello sul set di dati di convalida (punteggio F1 in questo caso), gli intervalli di iperparametri da cui selezionare i migliori valori di iperparametri, nonché le configurazioni del lavoro di ottimizzazione come numero massimo di processi di ottimizzazione e numero di processi paralleli da avviare contemporaneamente:

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)

Dopo che i lavori di ottimizzazione sono stati completati, distribuiamo il modello che fornisce il miglior punteggio della metrica di valutazione sul set di dati di convalida, eseguiamo l'inferenza sullo stesso set di dati di test di hold-out che abbiamo fatto nella sezione precedente e calcoliamo le metriche di valutazione.

Possiamo vedere che il modello con HPO raggiunge prestazioni significativamente migliori in tutte le metriche.

Risposta alla domanda

La risposta alle domande è utile quando si desidera interrogare una grande quantità di testo per informazioni specifiche. Consente a un utente di esprimere una domanda in linguaggio naturale e ottenere una risposta immediata e breve. I sistemi di risposta alle domande alimentati dalla PNL possono essere utilizzati nei motori di ricerca e nelle interfacce di conversazione telefonica.

Distribuisci ed esegui l'inferenza sul modello preaddestrato

Il nostro modello pre-addestrato è il modello di risposta alle domande estrattive (EQA). bert-large-uncased-intera-parola-mascherante-perfezionata-squadra costruito su un modello Transformer di Hugging Face. Utilizziamo un DLC AWS PyTorch con una modalità script e installiamo il file trasformatori library come dipendenza in cima al contenitore. Simile all'attività NER, forniamo un file di archivio vuoto nell'argomento model_data perché il modello pre-addestrato viene scaricato al volo. Dopo che l'endpoint è stato distribuito, puoi richiamare l'endpoint direttamente dal notebook utilizzando SageMaker Python SDK Predictor. Vedi il seguente codice:

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

Tutto quello che dobbiamo fare è costruire un oggetto dizionario con due chiavi. context è il testo da cui vogliamo recuperare le informazioni. question è la query in linguaggio naturale che specifica quali informazioni siamo interessati a estrarre. Noi chiamiamo predict sul nostro predittore e dovremmo ottenere una risposta dall'endpoint che contiene le risposte più probabili:

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

Abbiamo la risposta e possiamo stampare le risposte più probabili che sono state estratte dal testo precedente. Ogni risposta ha un punteggio di confidenza utilizzato per la classifica (ma questo punteggio non deve essere interpretato come una vera probabilità). Oltre alla risposta letterale, ottieni anche gli indici dei caratteri di inizio e fine della risposta dal contesto originale:

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

Ora perfezioniamo questo modello con il nostro set di dati personalizzato per ottenere risultati migliori.

Ottimizza il modello pre-addestrato su un set di dati personalizzato

In questa fase, dimostriamo come mettere a punto un modello linguistico pre-addestrato per EQA sul tuo set di dati. La fase di fine tuning aggiorna i parametri del modello per acquisire le caratteristiche dei propri dati e migliorare la precisione. Noi usiamo il SQuAD2.0 set di dati per mettere a punto un modello di incorporamento del testo bert-base-senza custodia da Volto che abbraccia. Il modello disponibile per la messa a punto collega un livello di estrazione della risposta al modello di incorporamento del testo e inizializza i parametri del livello su valori casuali. La fase di fine tuning ottimizza tutti i parametri del modello per ridurre al minimo l'errore di previsione sui dati di input e restituisce il modello finemente ottimizzato.

Analogamente all'attività di classificazione del testo, il set di dati (SQuAD2.0) è suddiviso in set di addestramento, convalida e test.

Successivamente, specifichiamo gli iperparametri del modello e utilizziamo il API JumpStart per attivare un lavoro di fine tuning:

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)

Una volta completato il lavoro di fine tuning, distribuiamo il modello, eseguiamo l'inferenza sul set di dati di test di hold-out e calcoliamo le metriche di valutazione. Le metriche di valutazione utilizzate sono il punteggio medio di corrispondenza esatta e il punteggio medio F1. Lo screenshot seguente mostra i risultati.

Migliora ulteriormente le prestazioni di messa a punto con la messa a punto automatica del modello SageMaker

Analogamente alle sezioni precedenti, usiamo a HyperparameterTuner oggetto per avviare i lavori di ottimizzazione:

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

Dopo che i lavori di ottimizzazione sono stati completati, distribuiamo il modello che fornisce il miglior punteggio della metrica di valutazione sul set di dati di convalida, eseguiamo l'inferenza sullo stesso set di dati di test di hold-out che abbiamo fatto nella sezione precedente e calcoliamo le metriche di valutazione.

Possiamo vedere che il modello con HPO mostra prestazioni significativamente migliori sui dati del test di tenuta.

Estrazione di relazioni

L'estrazione delle relazioni è il compito di estrarre le relazioni semantiche dal testo, che di solito si verificano tra due o più entità. L'estrazione delle relazioni svolge un ruolo importante nell'estrazione di informazioni strutturate da fonti non strutturate come il testo non elaborato. In questo notebook, dimostriamo due casi d'uso dell'estrazione di relazioni.

Ottimizza il modello pre-addestrato su un set di dati personalizzato

Utilizziamo un modello di estrazione delle relazioni costruito su a BERT-base-senza custodia modello utilizzando trasformatori dal Trasformatori faccia abbracciante biblioteca. Il modello per la messa a punto collega un livello di classificazione lineare che prende una coppia di incorporamenti di token emessi dal modello di incorporamento del testo e inizializza i parametri del livello su valori casuali. La fase di fine tuning ottimizza tutti i parametri del modello per ridurre al minimo l'errore di previsione sui dati di input e restituisce il modello finemente ottimizzato.

Il set di dati con cui perfezioniamo il modello è SemEval-2010 Compito 8. Il modello restituito dal fine tuning può essere ulteriormente distribuito per l'inferenza.

Il set di dati contiene set di addestramento, convalida e test.

Utilizziamo il DLC AWS PyTorch con una modalità script da SageMaker Python SDK, dove il file transformers library è installata come dipendenza sopra il contenitore. Definiamo SageMaker PyTorch stimatore e un insieme di iperparametri come il modello pre-addestrato, il tasso di apprendimento e i numeri di epoca per eseguire la messa a punto. Il codice per la messa a punto del modello di estrazione delle relazioni è definito nel file entry_point.py. Vedi il seguente codice:

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

Migliora ulteriormente le prestazioni di messa a punto con la messa a punto automatica del modello SageMaker

Analogamente alle sezioni precedenti, usiamo a HyperparameterTuner oggetto per interagire con le API di ottimizzazione degli iperparametri di SageMaker. Possiamo avviare il lavoro di ottimizzazione degli iperparametri chiamando il metodo fit Metodo:

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

Quando il lavoro di ottimizzazione degli iperparametri è completo, eseguiamo l'inferenza e controlliamo il punteggio di valutazione.

Possiamo vedere che il modello con HPO mostra prestazioni migliori sui dati del test di tenuta.

Sintesi del documento

Il riepilogo del documento o del testo è il compito di condensare grandi quantità di dati di testo in un sottoinsieme più piccolo di frasi significative che rappresentano le informazioni più importanti o rilevanti all'interno del contenuto originale. Il riepilogo del documento è una tecnica utile per distillare informazioni importanti da grandi quantità di dati di testo a poche frasi. Il riepilogo del testo viene utilizzato in molti casi d'uso, come l'elaborazione di documenti e l'estrazione di informazioni da blog, articoli e notizie.

Questo notebook dimostra la distribuzione del modello di riepilogo dei documenti Base T5 dal Trasformatori faccia abbracciante biblioteca. Testiamo anche gli endpoint distribuiti utilizzando un articolo di testo e valutiamo i risultati utilizzando la metrica di valutazione integrata Hugging Face ROUGE.

Simile alla risposta alle domande e ai taccuini NER, usiamo il PyTorchModel da SageMaker Python SDK insieme a un file entry_point.py script per caricare il modello di base T5 su un endpoint HTTPS. Dopo che l'endpoint è stato distribuito correttamente, possiamo inviare un articolo di testo all'endpoint per ottenere una risposta di previsione:

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

Successivamente, valutiamo e confrontiamo l'articolo di testo e il risultato del riepilogo utilizzando la metrica ROUGE. Vengono calcolate tre metriche di valutazione: rougeN, rougeLe rougeLsum. rougeN misura il numero di corrispondenze n-grams tra il testo generato dal modello (risultato del riepilogo) e a reference (testo di input). Le metriche rougeL ed rougeLsum misurare le sequenze di parole corrispondenti più lunghe cercando le sottostringhe comuni più lunghe nei riepiloghi generati e di riferimento. Per ogni metrica vengono calcolati gli intervalli di confidenza per precisione, richiamo e punteggio F1.Vedere il seguente codice:

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

ripulire

Le risorse create per questa soluzione possono essere eliminate utilizzando il file Elimina tutte le risorse pulsante dall'IDE di SageMaker Studio. Ogni notebook fornisce anche una sezione di pulizia con il codice per eliminare gli endpoint.

Conclusione

In questo post, abbiamo dimostrato come utilizzare tecniche ML all'avanguardia per risolvere cinque diverse attività di PNL: riepilogo dei documenti, classificazione del testo, domande e risposte, riconoscimento di entità denominate ed estrazione di relazioni utilizzando Jumpstart. Inizia subito con Jumpstart!

Informazioni sugli autori

Dott. Xin Huang è uno scienziato applicato per gli algoritmi integrati Amazon SageMaker JumpStart e Amazon SageMaker. Si concentra sullo sviluppo di algoritmi di apprendimento automatico scalabili. I suoi interessi di ricerca sono nell'area dell'elaborazione del linguaggio naturale, del deep learning spiegabile su dati tabulari e dell'analisi robusta del clustering spazio-temporale non parametrico. Ha pubblicato molti articoli su ACL, ICDM, conferenze KDD e Royal Statistical Society: rivista di serie A.

Vivek Gangasani è Senior Machine Learning Solutions Architect presso Amazon Web Services. Aiuta le startup a creare e rendere operative le applicazioni AI/ML. Attualmente è concentrato sulla combinazione del suo background in container e machine learning per fornire soluzioni su MLOps, ML Inference e ML low-code. Nel tempo libero si diverte a provare nuovi ristoranti ed esplorare le tendenze emergenti nell'intelligenza artificiale e nel deep learning.

Geremia Cohen è un Solutions Architect con AWS, dove aiuta i clienti a creare soluzioni all'avanguardia basate su cloud. Nel tempo libero, ama fare brevi passeggiate sulla spiaggia, esplorare la baia con la sua famiglia, aggiustare le cose in casa, rompere le cose intorno alla casa e fare barbecue.

Neelam Koshiya è un architetto di soluzioni aziendali presso AWS. Il suo obiettivo attuale è aiutare i clienti aziendali nel loro percorso di adozione del cloud per ottenere risultati aziendali strategici. Nel tempo libero le piace leggere e stare all'aria aperta.