Ajuste fino de un modelo de PNL preentrenado

Mueve tu manita para hacer una fortuna, ¡dale un pulgar hacia arriba!

Una guía paso a paso para ajustar modelos de PNL previamente entrenados para cualquier dominio

Introducción

En el mundo actual, la disponibilidad de modelos NLP preentrenados simplifica enormemente la interpretación de datos de texto utilizando técnicas de aprendizaje profundo. Sin embargo, aunque estos modelos funcionan bien en tareas generales, a menudo carecen de adaptabilidad específica de dominio. Esta guía integral ^[1] tiene como objetivo guiarlo a través del proceso de ajuste fino de los modelos NLP entrenados previamente para mejorar el rendimiento específico del dominio.

motivación

Aunque los modelos NLP previamente entrenados como BERT y Universal Sentence Encoder (USE) pueden capturar de manera efectiva la complejidad del lenguaje, su rendimiento en aplicaciones específicas de dominio puede verse limitado debido a la variedad de conjuntos de datos de entrenamiento. Esta limitación se hace evidente cuando se analizan las relaciones dentro de un dominio particular.

Por ejemplo, cuando se trabaja con datos de empleo, queremos que el modelo reconozca una relación más cercana entre los roles de "Científico de datos" e "Ingeniero de aprendizaje automático", o una asociación más fuerte entre "Python" y "TensorFlow". Desafortunadamente, los modelos generales a menudo ignoran estas sutiles relaciones.

La siguiente tabla muestra la diferencia de similitud obtenida del modelo USE multilingüe básico:

Para resolver este problema, podemos usar conjuntos de datos específicos de dominio de alta calidad para ajustar modelos previamente entrenados. Este proceso de adaptación mejora significativamente el rendimiento y la precisión del modelo, liberando todo el potencial de los modelos NLP.

❝

Cuando se trata de grandes modelos de NLP previamente entrenados, se recomienda implementar primero el modelo base y considerar el ajuste fino solo si su rendimiento no resuelve el problema específico en cuestión.

❞

Este tutorial se centra en el ajuste fino de un modelo Universal Sentence Encoder (USE) utilizando datos de código abierto de fácil acceso.

Los modelos ML se pueden ajustar a través de varias estrategias, como el aprendizaje supervisado y el aprendizaje por refuerzo. En este tutorial, nos centraremos en los métodos de aprendizaje de un paso (pocos pasos) combinados con arquitecturas siamesas para el proceso de ajuste fino.

Marco teórico

Los modelos ML se pueden ajustar a través de varias estrategias, como el aprendizaje supervisado y el aprendizaje por refuerzo. En este tutorial, nos centraremos en los métodos de aprendizaje de un paso (pocos pasos) combinados con arquitecturas siamesas para el proceso de ajuste fino.

método

En este tutorial, usamos una red neuronal siamesa, que es un tipo específico de red neuronal artificial. La red utiliza pesos compartidos para procesar simultáneamente dos vectores de entrada diferentes para calcular vectores de salida comparables. Inspirado en el aprendizaje de una sola vez, este enfoque ha demostrado ser particularmente efectivo para capturar la similitud semántica, aunque puede requerir un tiempo de entrenamiento más largo y carece de un resultado probabilístico.

Las redes neuronales siamesas crean un "espacio de incrustación" en el que los conceptos relacionados se ubican de cerca, lo que permite que el modelo discierna mejor las relaciones semánticas.

• 双分支和共享权重：该架构由两个相同的分支组成，每个分支都包含一个具有共享权重的嵌入层。这些双分支同时处理两个输入，无论是相似的还是不相似的。
• 相似性和转换：使用预先训练的 NLP 模型将输入转换为向量嵌入。然后该架构计算向量之间的相似度。相似度得分（范围在 -1 到 1 之间）量化两个向量之间的角距离，作为它们语义相似度的度量。
• 对比损失和学习：模型的学习以“对比损失”为指导，即预期输出（训练数据的相似度得分）与计算出的相似度之间的差异。这种损失指导模型权重的调整，以最大限度地减少损失并提高学习嵌入的质量。

数据概览

为了使用此方法对预训练的 NLP 模型进行微调，训练数据应由文本字符串对组成，并附有它们之间的相似度分数。

训练数据遵循如下所示的格式：

在本教程中，我们使用源自 ESCO 分类数据集的数据集，该数据集已转换为基于不同数据元素之间的关系生成相似性分数。

❝

准备训练数据是微调过程中的关键步骤。假设您有权访问所需的数据以及将其转换为指定格式的方法。由于本文的重点是演示微调过程，因此我们将省略如何使用 ESCO 数据集生成数据的详细信息。

ESCO 数据集可供开发人员自由使用，作为各种应用程序的基础，这些应用程序提供自动完成、建议系统、职位搜索算法和职位匹配算法等服务。本教程中使用的数据集已被转换并作为示例提供，允许不受限制地用于任何目的。

❞

让我们首先检查训练数据：

import pandas as pd

# Read the CSV file into a pandas DataFrame
data = pd.read_csv("./data/training_data.csv")

# Print head
data.head()

起点：基线模型

首先，我们建立多语言通用句子编码器作为我们的基线模型。在进行微调过程之前，必须设置此基线。

在本教程中，我们将使用 STS 基准和相似性可视化示例作为指标来评估通过微调过程实现的更改和改进。

❝

STS 基准数据集由英语句子对组成，每个句子对都与相似度得分相关联。在模型训练过程中，我们评估模型在此基准集上的性能。每次训练运行的持久分数是数据集中预测相似性分数和实际相似性分数之间的皮尔逊相关性。

Estos puntajes aseguran que cuando el modelo se ajusta con precisión en nuestros datos de entrenamiento específicos del contexto, conserva cierto nivel de generalización.

❞

# Loads the Universal Sentence Encoder Multilingual module from TensorFlow Hub.
base_model_url = "https://tfhub.dev/google/universal-sentence-encoder-multilingual/3"
base_model = tf.keras.Sequential([
    hub.KerasLayer(base_model_url,
                   input_shape=[],
                   dtype=tf.string,
                   trainable=False)
])

# Defines a list of test sentences. These sentences represent various job titles.
test_text = ['Data Scientist', 'Data Analyst', 'Data Engineer',
             'Nurse Practitioner', 'Registered Nurse', 'Medical Assistant',
             'Social Media Manager', 'Marketing Strategist', 'Product Marketing Manager']

# Creates embeddings for the sentences in the test_text list. 
# The np.array() function is used to convert the result into a numpy array.
# The .tolist() function is used to convert the numpy array into a list, which might be easier to work with.
vectors = np.array(base_model.predict(test_text)).tolist()

# Calls the plot_similarity function to create a similarity plot.
plot_similarity(test_text, vectors, 90, "base model")

# Computes STS benchmark score for the base model
pearsonr = sts_benchmark(base_model)
print("STS Benachmark: " + str(pearsonr))

Afinando el modelo

El siguiente paso consiste en construir una arquitectura de modelo siamés utilizando el modelo de referencia y ajustarlo utilizando nuestros datos específicos del dominio.

# Load the pre-trained word embedding model
embedding_layer = hub.load(base_model_url)

# Create a Keras layer from the loaded embedding model
shared_embedding_layer = hub.KerasLayer(embedding_layer, trainable=True)

# Define the inputs to the model
left_input = keras.Input(shape=(), dtype=tf.string)
right_input = keras.Input(shape=(), dtype=tf.string)

# Pass the inputs through the shared embedding layer
embedding_left_output = shared_embedding_layer(left_input)
embedding_right_output = shared_embedding_layer(right_input)

# Compute the cosine similarity between the embedding vectors
cosine_similarity = tf.keras.layers.Dot(axes=-1, normalize=True)(
    [embedding_left_output, embedding_right_output]
)

# Convert the cosine similarity to angular distance
pi = tf.constant(math.pi, dtype=tf.float32)
clip_cosine_similarities = tf.clip_by_value(
    cosine_similarity, -0.99999, 0.99999
)
acos_distance = 1.0 - (tf.acos(clip_cosine_similarities) / pi)

# Package the model
encoder = tf.keras.Model([left_input, right_input], acos_distance)

# Compile the model
encoder.compile(
    optimizer=tf.keras.optimizers.Adam(
        learning_rate=0.00001,
        beta_1=0.9,
        beta_2=0.9999,
        epsilon=0.0000001,
        amsgrad=False,
        clipnorm=1.0,
        name="Adam",
    ),
    loss=tf.keras.losses.MeanSquaredError(
        reduction=keras.losses.Reduction.AUTO, name="mean_squared_error"
    ),
    metrics=[
        tf.keras.metrics.MeanAbsoluteError(),
        tf.keras.metrics.MeanAbsolutePercentageError(),
    ],
)

# Print the model summary
encoder.summary()

• Modelo de ajuste

# Define early stopping callback
early_stop = keras.callbacks.EarlyStopping(
    monitor="loss", patience=3, min_delta=0.001
)

# Define TensorBoard callback
logdir = os.path.join(".", "logs/fit/" + datetime.now().strftime("%Y%m%d-%H%M%S"))
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

# Model Input
left_inputs, right_inputs, similarity = process_model_input(data)

# Train the encoder model
history = encoder.fit(
    [left_inputs, right_inputs],
    similarity,
    batch_size=8,
    epochs=20,
    validation_split=0.2,
    callbacks=[early_stop, tensorboard_callback],
)

# Define model input
inputs = keras.Input(shape=[], dtype=tf.string)

# Pass the input through the embedding layer
embedding = hub.KerasLayer(embedding_layer)(inputs)

# Create the tuned model
tuned_model = keras.Model(inputs=inputs, outputs=embedding)

resultado de la evaluación

Ahora que tenemos el modelo ajustado, volvamos a evaluarlo y comparemos los resultados con los del modelo base.

# Creates embeddings for the sentences in the test_text list. 
# The np.array() function is used to convert the result into a numpy array.
# The .tolist() function is used to convert the numpy array into a list, which might be easier to work with.
vectors = np.array(tuned_model.predict(test_text)).tolist()

# Calls the plot_similarity function to create a similarity plot.
plot_similarity(test_text, vectors, 90, "tuned model")

# Computes STS benchmark score for the tuned model
pearsonr = sts_benchmark(tuned_model)
print("STS Benachmark: " + str(pearsonr))

Basado en el ajuste fino del modelo en un conjunto de datos relativamente pequeño, los puntajes de referencia de STS son comparables con los del modelo de referencia, lo que indica que el modelo ajustado aún es generalizable. Sin embargo, la visualización de similitud muestra que la puntuación de similitud entre títulos similares aumenta, mientras que la de títulos diferentes disminuye.

Resumir

El ajuste fino de un modelo de PNL previamente entrenado para la adaptación del dominio es una técnica poderosa que puede mejorar su rendimiento y precisión en contextos específicos. Al aprovechar los conjuntos de datos específicos de dominio de alta calidad y las redes neuronales siamesas, podemos mejorar la capacidad del modelo para capturar la similitud semántica.

Este tutorial proporciona una guía paso a paso para el proceso de ajuste fino, utilizando el modelo Universal Sentence Encoder (USE) como ejemplo. Exploramos el marco teórico, la preparación de datos, la evaluación del modelo de referencia y el proceso práctico de ajuste. Los resultados demuestran la eficacia del ajuste fino para mejorar la puntuación de similitud en el dominio.

Al seguir este enfoque y adaptarlo a su dominio específico, puede desbloquear todo el potencial de los modelos NLP entrenados previamente y lograr mejores resultados en las tareas de procesamiento del lenguaje natural.

Referencia

[1]

Fuente:https://towardsdatascience.com/domain-adaption-fine-tune-pre-trained-nlp-models-a06659ca6668

Este artículo es publicado por mdnice multiplataforma