Identifique os principais insights de documentos de texto por meio de ajuste fino e HPO com o Amazon SageMaker JumpStart

Organizações em setores como varejo, bancos, finanças, saúde, manufatura e empréstimos geralmente precisam lidar com grandes quantidades de documentos de texto não estruturados provenientes de várias fontes, como notícias, blogs, análises de produtos, canais de suporte ao cliente e mídias sociais. Esses documentos contêm informações críticas que são essenciais para a tomada de importantes decisões de negócios. À medida que uma organização cresce, torna-se um desafio extrair informações críticas desses documentos. Com o avanço das técnicas de processamento de linguagem natural (NLP) e aprendizado de máquina (ML), podemos descobrir informações e conexões valiosas desses documentos textuais rapidamente e com alta precisão, ajudando assim as empresas a tomar decisões de negócios de qualidade no prazo. Os serviços de NLP totalmente gerenciados também aceleraram a adoção do NLP. Amazon Comprehend é um serviço totalmente gerenciado que permite criar modelos de NLP personalizados específicos para suas necessidades, sem a necessidade de nenhum conhecimento de ML.

Nesta postagem, demonstramos como utilizar técnicas de ML de última geração para resolver cinco tarefas diferentes de NLP: resumo de documentos, classificação de texto, resposta a perguntas, reconhecimento de entidade nomeada e extração de relacionamento. Para cada uma dessas tarefas de PNL, demonstramos como usar Amazon Sage Maker para realizar as seguintes ações:

• Implante e execute inferência em um modelo pré-treinado
• Ajuste o modelo pré-treinado em um novo conjunto de dados personalizado
• Melhore ainda mais o desempenho de ajuste fino com SageMaker ajuste automático do modelo
• Avalie o desempenho do modelo nos dados de teste de espera com várias métricas de avaliação

Embora abordemos cinco tarefas específicas de NLP nesta postagem, você pode usar esta solução como modelo para generalizar o ajuste fino de modelos pré-treinados com seu próprio conjunto de dados e, subsequentemente, executar a otimização de hiperparâmetros para melhorar a precisão.

Modelos de solução JumpStart

JumpStart do Amazon SageMaker fornece soluções completas com um clique para muitos casos de uso comuns de ML. Explore os seguintes casos de uso para obter mais informações sobre os modelos de solução disponíveis:

Os modelos de solução JumpStart cobrem uma variedade de casos de uso, em cada um dos quais vários modelos de solução diferentes são oferecidos (esta solução de Compreensão de Documentos está no caso de uso “Extrair e analisar dados de documentos”).

Escolha o modelo de solução que melhor se adapta ao seu caso de uso na página inicial do JumpStart. Para obter mais informações sobre soluções específicas em cada caso de uso e como iniciar uma solução JumpStart, consulte Modelos de solução.

Visão geral da solução

A imagem a seguir demonstra como você pode usar esta solução com componentes do SageMaker. Os trabalhos de treinamento do SageMaker são usados ​​para treinar os vários modelos de NLP, e os endpoints do SageMaker são usados ​​para implantar os modelos em cada estágio. Nós usamos Serviço de armazenamento simples da Amazon (Amazon S3) ao lado do SageMaker para armazenar os dados de treinamento e os artefatos do modelo, e Amazon CloudWatch para registrar as saídas de treinamento e endpoint.

Abra a solução Document Understanding

Navegue até a solução Document Understanding no JumpStart.

Agora podemos examinar mais de perto alguns dos recursos incluídos nesta solução, começando pelo notebook de demonstração.

Caderno de demonstração

Você pode usar o bloco de anotações de demonstração para enviar dados de exemplo para terminais de modelo já implantados para o resumo de documentos e tarefas de resposta a perguntas. O notebook de demonstração permite que você obtenha experiência prática consultando os dados de exemplo.

Depois de iniciar a solução Document Understanding, abra o notebook de demonstração escolhendo Usar endpoint no notebook.

Vamos nos aprofundar em cada um dos cinco notebooks principais para esta solução.

Pré-requisitos

In Estúdio Amazon SageMaker, verifique se você está usando o PyTorch 1.10 Python 3.8 CPU Optimized image/kernel para abrir os notebooks. O treinamento usa cinco instâncias ml.g4dn.2xlarge, então você deve gerar um solicitação de aumento de limite de serviço se sua conta exigir limites maiores para esse tipo.

Classificação de texto

A classificação de texto refere-se à classificação de uma frase de entrada para um dos rótulos de classe do conjunto de dados de treinamento. Este notebook demonstra como usar o API JumpStart para classificação de texto.

Implante e execute inferência no modelo pré-treinado

O modelo de classificação de texto que escolhemos usar é construído sobre uma incorporação de texto (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) modelo de Hub do TensorFlow, que é pré-treinado nos conjuntos de dados Wikipedia e BookCorpus.

O modelo disponível para implantação é criado anexando uma camada de classificação binária à saída do modelo de incorporação de texto e, em seguida, ajustando todo o modelo no SST-2 conjunto de dados, que é composto por críticas positivas e negativas de filmes.

Para executar a inferência neste modelo, primeiro precisamos baixar o contêiner de inferência (deploy_image_uri), script de inferência (deploy_source_uri) e modelo pré-treinado (base_model_uri). Em seguida, os passamos como parâmetros para instanciar um objeto de modelo do SageMaker, que podemos implantar:

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 "

O código a seguir mostra nossas respostas:

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

Ajuste o modelo pré-treinado em um conjunto de dados personalizado

Acabamos de passar pela execução da inferência em um modelo BERT pré-treinado, que foi ajustado no SST-2 conjunto de dados.

Em seguida, discutimos como ajustar um modelo em um conjunto de dados personalizado com qualquer número de classes. O conjunto de dados que usamos para o ajuste fino ainda é o SST-2 conjunto de dados. Você pode substituir esse conjunto de dados por qualquer conjunto de dados de seu interesse.

Recuperamos o contêiner do Docker de treinamento, a fonte do algoritmo de treinamento e o modelo pré-treinado:

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

Para hiperparâmetros específicos do algoritmo, começamos buscando um dicionário Python dos hiperparâmetros de treinamento que o algoritmo aceita com seus valores padrão. Você pode substituí-los por valores personalizados, conforme mostrado no código a seguir:

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"

O conjunto de dados (SST-2) é dividido em conjuntos de treinamento, validação e teste, em que o conjunto de treinamento é usado para ajustar o modelo, o conjunto de validação é usado para calcular métricas de avaliação que podem ser usadas para HPO e o conjunto de teste é usado como dados de retenção para avaliar o desempenho do modelo. Em seguida, o conjunto de dados de treinamento e validação é carregado no Amazon S3 e usado para iniciar o trabalho de treinamento de ajuste fino:

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

Após a conclusão do trabalho de ajuste fino, implantamos o modelo, executamos a inferência no conjunto de dados de teste de retenção e calculamos as métricas de avaliação. Por ser uma tarefa de classificação binária, usamos o pontuação de precisão e Pontuação F1 como as métricas de avaliação. Um valor maior indica o melhor desempenho. A captura de tela a seguir mostra nossos resultados.

Melhore ainda mais o desempenho do ajuste fino com o ajuste automático de modelos do SageMaker

Nesta etapa, demonstramos como você pode melhorar ainda mais o desempenho do modelo ajustando o modelo com o ajuste automático de modelo do SageMaker. O ajuste automático de modelo, também conhecido como otimização de hiperparâmetros (HPO), encontra a melhor versão de um modelo executando vários trabalhos de treinamento em seu conjunto de dados com uma variedade de hiperparâmetros que você especifica. Em seguida, ele escolhe os valores de hiperparâmetros que resultam em um modelo com melhor desempenho, conforme medido por uma métrica escolhida por você, no conjunto de dados de validação.

Primeiro, definimos o objetivo como a pontuação de precisão nos dados de validação (val_accuracy) e métricas definidas para o trabalho de ajuste especificando o nome da métrica objetiva e uma expressão regular (regex). A expressão regular é usada para corresponder à saída de log do algoritmo e capturar os valores numéricos das métricas. Em seguida, especificamos intervalos de hiperparâmetros para selecionar os melhores valores de hiperparâmetros. Definimos o número total de tarefas de ajuste como seis e distribuímos essas tarefas em três diferentes Amazon Elastic Compute Nuvem (Amazon EC2) instâncias para executar tarefas de ajuste paralelo. Veja o seguinte código:

# 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

Passamos esses valores para instanciar um objeto SageMaker Estimator, semelhante ao que fizemos na etapa anterior de ajuste fino. Em vez de ligar para o fit função do Estimator objeto, passamos o Estimator objeto como um parâmetro para o HiperparâmetroTuner construtor e chame o fit função dele para iniciar tarefas de ajuste:

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

Após a conclusão dos trabalhos de ajuste, implantamos o modelo que fornece a melhor pontuação de métrica de avaliação no conjunto de dados de validação, realizamos inferência no mesmo conjunto de dados de teste de validação que fizemos na seção anterior e calculamos as métricas de avaliação.

Os resultados mostram que o modelo selecionado pelo ajuste automático de modelo supera significativamente o modelo ajustado na seção anterior em um conjunto de dados de teste de validação.

Reconhecimento de entidade nomeada

Reconhecimento de entidade nomeada (NER) é o processo de detecção e classificação de entidades nomeadas em categorias predefinidas, como nomes de pessoas, organizações, locais e quantidades. Existem muitos casos de uso do mundo real para o NER, como mecanismos de recomendação, categorização e atribuição de tíquetes de suporte ao cliente ao departamento certo, extração de informações essenciais de relatórios de pacientes na área da saúde e classificação de conteúdo de notícias e blogs.

Implante e execute inferência no modelo pré-treinado

Nós implantamos o En_core_web_md modelo do ESPAÇO biblioteca. spaCy é uma biblioteca NLP de código aberto que pode ser usada para várias tarefas e possui métodos integrados para NER. Usamos um AWS PyTorch Deep Learning Container (DLC) com um modo de script e instalamos a biblioteca spaCy como uma dependência na parte superior do contêiner.

Em seguida, um ponto de entrada para o script (argumento entry_point.py) é especificado, contendo todo o código para baixar e carregar o En_core_web_md modele e execute inferência nos dados que são enviados para o endpoint. Finalmente, ainda precisamos fornecer model_data como o modelo pré-treinado para inferência. Porque o pré-treinado En_core_web_md modelo é baixado em tempo real, que é especificado no script de entrada, fornecemos um arquivo vazio. Após a implantação do endpoint, você pode invocá-lo diretamente do notebook usando o SageMaker Python SDK Predictor. Veja o seguinte código:

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

Os dados de entrada para o modelo são um documento textual. O modelo de entidade nomeada extrai blocos de substantivos e entidades nomeadas no documento textual e os classifica em vários tipos diferentes (como pessoas, lugares e organizações). A entrada e a saída de exemplo são mostradas no código a seguir. o start_char parâmetro indica o deslocamento de caractere para o início do intervalo e end_char indica o fim do vão.

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

Ajuste o modelo pré-treinado em um conjunto de dados personalizado

Nesta etapa, demonstramos como ajustar modelos de linguagem pré-treinados para NER em seu próprio conjunto de dados. A etapa de ajuste fino atualiza os parâmetros do modelo para capturar a característica de seus próprios dados e melhorar a precisão. Nós usamos o WikiANN (PAN-X) conjunto de dados para ajustar o DestilBERT-base-uncased Modelo Transformer da Hugging Face.

O conjunto de dados é dividido em conjuntos de treinamento, validação e teste.

Em seguida, especificamos os hiperparâmetros do modelo e usamos um DLC AWS Hugging Face com um modo de script (argumento entry_point) para acionar o trabalho de ajuste fino:

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
)

Após a conclusão do trabalho de ajuste fino, implantamos um endpoint e consultamos esse endpoint com os dados de teste de validação. Para consultar o endpoint, cada sequência de texto precisa ser tokenizada em um ou vários tokens e enviada ao modelo do transformador. Cada token recebe uma tag de entidade nomeada prevista. Como cada string de texto pode ser tokenizada em um ou vários tokens, precisamos duplicar a marca de entidade denominada verdade absoluta da string para todos os tokens associados a ela. O bloco de anotações fornecido orienta você nas etapas para fazer isso.

Por fim, usamos métricas de avaliação integradas do Hugging Face sequência para calcular pontuações de avaliação nos dados de teste de espera. As métricas de avaliação usadas são precisão geral, recall geral, F1 geral e precisão. A captura de tela a seguir mostra nossos resultados.

Melhore ainda mais o desempenho do ajuste fino com o ajuste automático de modelos do SageMaker

Semelhante à classificação de texto, demonstramos como você pode melhorar ainda mais o desempenho do modelo ajustando o modelo com o ajuste automático de modelo do SageMaker. Para executar o trabalho de ajuste, precisamos definir uma métrica objetiva que queremos usar para avaliar o desempenho do modelo no conjunto de dados de validação (pontuação F1 neste caso), intervalos de hiperparâmetros para selecionar os melhores valores de hiperparâmetros, bem como configurações de trabalho de ajuste, como número máximo de tarefas de ajuste e número de tarefas paralelas a serem iniciadas por vez:

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)

Após a conclusão dos trabalhos de ajuste, implantamos o modelo que fornece a melhor pontuação de métrica de avaliação no conjunto de dados de validação, realizamos inferência no mesmo conjunto de dados de teste de validação que fizemos na seção anterior e calculamos as métricas de avaliação.

Podemos ver que o modelo com HPO atinge um desempenho significativamente melhor em todas as métricas.

Resposta de perguntas

A resposta a perguntas é útil quando você deseja consultar uma grande quantidade de texto para obter informações específicas. Ele permite que um usuário expresse uma pergunta em linguagem natural e obtenha uma resposta imediata e breve. Os sistemas de resposta a perguntas alimentados por NLP podem ser usados ​​em mecanismos de pesquisa e interfaces de conversação telefônica.

Implante e execute inferência no modelo pré-treinado

Nosso modelo pré-treinado é o modelo de resposta a perguntas extrativas (EQA) bert-large-uncase-whole-word-masking-finetuned-squad construído em um modelo Transformer da Hugging Face. Usamos um AWS PyTorch DLC com um modo de script e instalamos o transformadores biblioteca como uma dependência na parte superior do contêiner. Semelhante à tarefa NER, fornecemos um arquivo compactado vazio no argumento model_data porque o modelo pré-treinado é baixado em tempo real. Após a implantação do endpoint, você pode invocá-lo diretamente do notebook usando o SageMaker Python SDK Predictor. Veja o seguinte código:

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

Tudo o que precisamos fazer é construir um objeto de dicionário com duas chaves. context é o texto do qual desejamos recuperar informações. question é a consulta de linguagem natural que especifica quais informações estamos interessados ​​em extrair. Nós chamamos predict em nosso preditor, e devemos obter uma resposta do endpoint que contém as respostas mais prováveis:

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

Temos a resposta e podemos imprimir as respostas mais prováveis ​​que foram extraídas do texto anterior. Cada resposta tem uma pontuação de confiança usada para classificação (mas essa pontuação não deve ser interpretada como uma probabilidade real). Além da resposta literal, você também obtém os índices de caracteres iniciais e finais da resposta do contexto original:

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

Agora, ajustamos esse modelo com nosso próprio conjunto de dados personalizado para obter melhores resultados.

Ajuste o modelo pré-treinado em um conjunto de dados personalizado

Nesta etapa, demonstramos como ajustar modelos de linguagem pré-treinados para EQA em seu próprio conjunto de dados. A etapa de ajuste fino atualiza os parâmetros do modelo para capturar a característica de seus próprios dados e melhorar a precisão. Nós usamos o SQUAD2.0 conjunto de dados para ajustar um modelo de incorporação de texto bert-base-uncase de Abraçar o Rosto. O modelo disponível para ajuste fino anexa uma camada de extração de resposta ao modelo de incorporação de texto e inicializa os parâmetros da camada com valores aleatórios. A etapa de ajuste fino ajusta todos os parâmetros do modelo para minimizar o erro de previsão nos dados de entrada e retorna o modelo ajustado com precisão.

Semelhante à tarefa de classificação de texto, o conjunto de dados (SQuAD2.0) é dividido em conjunto de treinamento, validação e teste.

Em seguida, especificamos os hiperparâmetros do modelo e usamos o API JumpStart para acionar um trabalho de ajuste fino:

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)

Após a conclusão do trabalho de ajuste fino, implantamos o modelo, executamos a inferência no conjunto de dados de teste de retenção e calculamos as métricas de avaliação. As métricas de avaliação usadas são a pontuação média exata de correspondência e a pontuação média da F1. A captura de tela a seguir mostra os resultados.

Melhore ainda mais o desempenho do ajuste fino com o ajuste automático de modelos do SageMaker

Semelhante às seções anteriores, usamos um HyperparameterTuner objeto para iniciar tarefas de ajuste:

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

Após a conclusão dos trabalhos de ajuste, implantamos o modelo que fornece a melhor pontuação de métrica de avaliação no conjunto de dados de validação, realizamos inferência no mesmo conjunto de dados de teste de validação que fizemos na seção anterior e calculamos as métricas de avaliação.

Podemos ver que o modelo com HPO apresenta um desempenho significativamente melhor nos dados do teste hold-out.

Extração de relacionamento

A extração de relacionamento é a tarefa de extrair relacionamentos semânticos do texto, que geralmente ocorrem entre duas ou mais entidades. A extração de relacionamento desempenha um papel importante na extração de informações estruturadas de fontes não estruturadas, como texto bruto. Neste notebook, demonstramos dois casos de uso de extração de relacionamento.

Ajuste o modelo pré-treinado em um conjunto de dados personalizado

Usamos um modelo de extração de relacionamento construído em um BERT-base-uncase modelo usando transformadores da Transformadores de rosto abraçando biblioteca. O modelo para ajuste fino anexa uma camada de classificação linear que usa um par de incorporações de token geradas pelo modelo de incorporação de texto e inicializa os parâmetros da camada com valores aleatórios. A etapa de ajuste fino ajusta todos os parâmetros do modelo para minimizar o erro de previsão nos dados de entrada e retorna o modelo ajustado com precisão.

O conjunto de dados que ajustamos o modelo é SemEval-2010 Tarefa 8. O modelo retornado pelo ajuste fino pode ser implantado posteriormente para inferência.

O conjunto de dados contém conjuntos de treinamento, validação e teste.

Usamos o AWS PyTorch DLC com um modo de script do SageMaker Python SDK, onde o transformers A biblioteca é instalada como a dependência na parte superior do contêiner. Nós definimos o SageMaker PyTorch estimador e um conjunto de hiperparâmetros, como o modelo pré-treinado, taxa de aprendizado e números de época para realizar o ajuste fino. O código para ajuste fino do modelo de extração de relacionamento é definido no entry_point.py. Veja o seguinte código:

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

Melhore ainda mais o desempenho do ajuste fino com o ajuste automático de modelos do SageMaker

Semelhante às seções anteriores, usamos um HyperparameterTuner para interagir com as APIs de ajuste de hiperparâmetros do SageMaker. Podemos iniciar o trabalho de ajuste de hiperparâmetro chamando o fit método:

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 o trabalho de ajuste do hiperparâmetro é concluído, realizamos a inferência e verificamos a pontuação da avaliação.

Podemos ver que o modelo com HPO apresenta melhor desempenho nos dados do teste hold-out.

Resumo do documento

Resumo de documento ou texto é a tarefa de condensar grandes quantidades de dados de texto em um subconjunto menor de frases significativas que representam as informações mais importantes ou relevantes dentro do conteúdo original. A sumarização de documentos é uma técnica útil para destilar informações importantes de grandes quantidades de dados de texto para algumas frases. O resumo de texto é usado em muitos casos de uso, como processamento de documentos e extração de informações de blogs, artigos e notícias.

Este notebook demonstra a implantação do modelo de resumo de documentos Base T5 do Transformadores de rosto abraçando biblioteca. Também testamos os endpoints implantados usando um artigo de texto e avaliamos os resultados usando a métrica de avaliação integrada Hugging Face ROUGE.

Semelhante à resposta a perguntas e aos cadernos NER, usamos o PyTorchModel do SageMaker Python SDK junto com um entry_point.py script para carregar o modelo T5-base para um endpoint HTTPS. Após a implantação bem-sucedida do endpoint, podemos enviar um artigo de texto ao endpoint para obter uma resposta de previsão:

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

Em seguida, avaliamos e comparamos o artigo de texto e o resultado do resumo usando a métrica ROUGE. Três métricas de avaliação são calculadas: rougeN, rougeL e rougeLsum. rougeN mede o número de correspondência n-grams entre o texto gerado pelo modelo (resultado do resumo) e um reference (Entrada de texto). As métricas rougeL e rougeLsum meça as sequências de palavras correspondentes mais longas procurando as substrings comuns mais longas nos resumos gerados e de referência. Para cada métrica, são calculados intervalos de confiança para precisão, recall e pontuação F1. Veja o código a seguir:

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

limpar

Os recursos criados para esta solução podem ser excluídos usando o Excluir todos os recursos botão do SageMaker Studio IDE. Cada notebook também fornece uma seção de limpeza com o código para excluir os terminais.

Conclusão

Nesta postagem, demonstramos como utilizar técnicas de ML de última geração para resolver cinco tarefas diferentes de NLP: resumo de documento, classificação de texto, pergunta e resposta, reconhecimento de entidade nomeada e extração de relacionamento usando o Jumpstart. Comece agora com o Jumpstart!

Sobre os autores

Dr.Xin Huang é um cientista aplicado para algoritmos integrados Amazon SageMaker JumpStart e Amazon SageMaker. Ele se concentra no desenvolvimento de algoritmos de aprendizado de máquina escaláveis. Seus interesses de pesquisa estão na área de processamento de linguagem natural, aprendizado profundo explicável em dados tabulares e análise robusta de agrupamento não paramétrico de espaço-tempo. Ele publicou muitos artigos em conferências ACL, ICDM, KDD e Royal Statistical Society: Series A journal.

Vivek Gangasani é arquiteto sênior de soluções de aprendizado de máquina na Amazon Web Services. Ele ajuda as startups a criar e operacionalizar aplicativos AI/ML. Atualmente, ele está focado em combinar sua experiência em contêineres e aprendizado de máquina para fornecer soluções em MLOps, inferência de ML e ML de baixo código. Em seu tempo livre, ele gosta de experimentar novos restaurantes e explorar tendências emergentes em IA e aprendizado profundo.

Geremy Cohen é Arquiteto de Soluções da AWS, onde ajuda os clientes a criar soluções de ponta baseadas em nuvem. Em seu tempo livre, ele gosta de caminhadas curtas na praia, explorando a área da baía com sua família, consertando coisas em casa, quebrando coisas em casa e fazendo churrasco.

Neelam Koshiya é arquiteto de soluções corporativas da AWS. Seu foco atual é ajudar os clientes corporativos em sua jornada de adoção da nuvem para resultados de negócios estratégicos. Em seu tempo livre, ela gosta de ler e estar ao ar livre.