Adaptation de domaine Ajuster finement les modèles NLP pré-entraînés

Domain Adaptation Fine-tuning Pre-trained NLP Models

Tutoriels pratiques

Un guide étape par étape pour affiner les modèles NLP pré-entraînés pour n’importe quel domaine

Préface: Cet article présente un résumé d’informations sur le sujet donné. Il ne doit pas être considéré comme une recherche originale. Les informations et le code inclus dans cet article peuvent avoir été influencés par des choses que j’ai lues ou vues dans le passé à partir de divers articles en ligne, documents de recherche, livres et code open-source.

Co-auteur: Billy Hines

Table des matières

• Introduction
• Cadre théorique
• Aperçu des données
• Point de départ: le modèle de référence
• Affiner le modèle
• Évaluer les résultats
• Réflexions finales

Introduction

Dans le monde d’aujourd’hui, la disponibilité de modèles NLP pré-entraînés a grandement simplifié l’interprétation des données textuelles en utilisant des techniques d’apprentissage profond. Cependant, bien que ces modèles excellent dans les tâches générales, ils manquent souvent d’adaptabilité à des domaines spécifiques. Ce guide complet vise à vous guider à travers le processus d’affinement des modèles NLP pré-entraînés pour obtenir de meilleures performances dans un domaine particulier.

Motivation

Les modèles NLP pré-entraînés tels que BERT et l’Universal Sentence Encoder (USE) sont efficaces pour capturer les subtilités linguistiques, mais leur performance dans des applications spécifiques à un domaine peut être limitée en raison de la diversité des ensembles de données sur lesquels ils sont entraînés. Cette limitation devient évidente lors de l’analyse des relations au sein d’un domaine spécifique.

• Édition de juillet Ressources sur le climat pour les scientifiques des données
• Git Tags Qu’est-ce que c’est et comment les utiliser
• Explication des bases de données vectorielles en 3 niveaux de difficulté

Par exemple, lorsqu’on travaille avec des données d’emploi, nous nous attendons à ce que le modèle reconnaisse la proximité plus étroite entre les rôles de ‘Data Scientist’ et de ‘Machine Learning Engineer’, ou l’association plus forte entre ‘Python’ et ‘TensorFlow’. Malheureusement, les modèles à usage général passent souvent à côté de ces relations nuancées.

Le tableau ci-dessous montre les différences de similarité obtenues à partir d’un modèle USE multilingue de base :

Pour résoudre ce problème, nous pouvons affiner les modèles pré-entraînés avec des ensembles de données de haute qualité spécifiques à un domaine. Ce processus d’adaptation améliore considérablement les performances et la précision du modèle, débloquant ainsi pleinement le potentiel du modèle NLP.

Lorsqu’on travaille avec de grands modèles NLP pré-entraînés, il est conseillé de déployer initialement le modèle de base et de considérer l’affinement uniquement si ses performances sont insuffisantes pour le problème spécifique en question.

Ce tutoriel se concentre sur l’affinement du modèle Universal Sentence Encoder (USE) en utilisant des données open-source facilement accessibles.

Aperçu théorique

L’affinement d’un modèle ML peut être réalisé grâce à diverses stratégies, telles que l’apprentissage supervisé et l’apprentissage par renforcement. Dans ce tutoriel, nous nous concentrerons sur une approche d’apprentissage en un (ou quelques) tir(s) combinée à une architecture siamoise pour le processus d’affinement.

Méthodologie

Dans ce tutoriel, nous utilisons un réseau neuronal siamois, qui est un type spécifique de réseau neuronal artificiel. Ce réseau exploite des poids partagés tout en traitant simultanément deux vecteurs d’entrée distincts pour calculer des vecteurs de sortie comparables. Inspirée de l’apprentissage en un seul tir, cette approche s’est révélée particulièrement efficace pour capturer la similarité sémantique, bien qu’elle puisse nécessiter des temps d’apprentissage plus longs et ne pas fournir de sortie probabiliste.

Un réseau neuronal siamois crée un “espace d’embedding” où les concepts liés sont positionnés à proximité, ce qui permet au modèle de mieux discerner les relations sémantiques.

• Branches jumelles et poids partagés : L’architecture se compose de deux branches identiques, chacune contenant une couche d’incorporation avec des poids partagés. Ces branches jumelles traitent simultanément deux entrées, qu’elles soient similaires ou différentes.
• Similarité et transformation : Les entrées sont transformées en vecteurs d’incorporation à l’aide du modèle de traitement du langage naturel pré-entraîné. L’architecture calcule ensuite la similarité entre les vecteurs. Le score de similarité, qui varie entre -1 et 1, quantifie la distance angulaire entre les deux vecteurs, servant de métrique pour leur similarité sémantique.
• Perte contrastive et apprentissage : L’apprentissage du modèle est guidé par la “perte contrastive”, qui est la différence entre la sortie attendue (score de similarité à partir des données d’entraînement) et la similarité calculée. Cette perte guide l’ajustement des poids du modèle pour minimiser la perte et améliorer la qualité des vecteurs d’incorporation appris.

Pour en savoir plus sur l’apprentissage à (quelques) un coup, l’architecture siamoise et la perte contrastive, consultez les ressources suivantes :

Une Introduction aux Architectures de Réseaux Neuronaux Siamois

Architecture des Réseaux Neuronaux Siamois : Aperçu et Concepts Clés Expliqués avec des Exemples | ProjectPro

www.projectpro.io

Qu’est-ce que l’apprentissage à un coup ? – TechTalks

L’apprentissage à un coup permet aux algorithmes d’apprentissage profond de mesurer la similarité et la différence entre deux images.

bdtechtalks.com

Explication de la Perte Contrastive

La perte contrastive a récemment été utilisée dans plusieurs articles montrant des résultats de pointe avec l’apprentissage non supervisé…

towardsdatascience.com

Le code complet est disponible sous forme de notebook Jupyter sur GitHub

Aperçu des Données

Pour le réglage fin des modèles de traitement du langage naturel pré-entraînés en utilisant cette méthode, les données d’entraînement doivent consister en paires de chaînes de texte accompagnées de scores de similarité entre elles.

Les données d’entraînement suivent le format indiqué ci-dessous :

Dans ce tutoriel, nous utilisons un ensemble de données provenant de l’ensemble de classification ESCO, qui a été transformé pour générer des scores de similarité en fonction des relations entre différents éléments de données.

La préparation des données d’entraînement est une étape cruciale du processus de réglage fin. Il est supposé que vous avez accès aux données requises et à une méthode pour les transformer dans le format spécifié. Étant donné que l’objectif de cet article est de démontrer le processus de réglage fin, nous omettrons les détails sur la façon dont les données ont été générées à l’aide de l’ensemble de données ESCO.

L’ensemble de données ESCO est disponible pour les développeurs afin de l’utiliser librement comme base pour diverses applications offrant des services tels que l’autocomplétion, les systèmes de suggestion, les algorithmes de recherche d’emploi et les algorithmes de correspondance d’emploi. L’ensemble de données utilisé dans ce tutoriel a été transformé et fourni comme exemple, permettant une utilisation illimitée à des fins quelconques.

Commençons par examiner les données d’entraînement :

import pandas as pd# Lire le fichier CSV dans un DataFrame pandasdata = pd.read_csv("./data/training_data.csv")# Afficher les premières lignesdata.head()

Point de Départ : Le Modèle de Base

Pour commencer, nous établissons l’encodeur de phrase multilingue universel comme notre modèle de base. Il est essentiel de définir cette base avant de procéder au réglage fin du modèle.

Pour ce tutoriel, nous utiliserons le benchmark STS et une visualisation de similarité d’échantillon en tant que métriques pour évaluer les changements et les améliorations réalisés grâce au processus d’affinage.

L’ensemble de données du benchmark STS se compose de paires de phrases en anglais, chacune étant associée à un score de similarité. Au cours du processus de formation du modèle, nous évaluons les performances du modèle sur cet ensemble de référence. Les scores persistés pour chaque exécution d’entraînement sont la corrélation de Pearson entre les scores de similarité prédits et les scores de similarité réels dans l’ensemble de données.

Ces scores garantissent que, lorsque le modèle est affiné avec nos données d’entraînement spécifiques au contexte, il maintient un certain niveau de généralisabilité.

# Charge le module Universal Sentence Encoder Multilingual à partir de 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)])# Définit une liste de phrases de test. Ces phrases représentent divers titres de poste.test_text = ['Data Scientist', 'Data Analyst', 'Data Engineer',             'Nurse Practitioner', 'Registered Nurse', 'Medical Assistant',             'Social Media Manager', 'Marketing Strategist', 'Product Marketing Manager']# Crée des embeddings pour les phrases de la liste test_text. # La fonction np.array() est utilisée pour convertir le résultat en un tableau numpy.# La fonction .tolist() est utilisée pour convertir le tableau numpy en une liste, ce qui peut être plus facile à manipuler.vectors = np.array(base_model.predict(test_text)).tolist()# Appelle la fonction plot_similarity pour créer un graphique de similarité.plot_similarity(test_text, vectors, 90, "modèle de base")# Calcule le score de référence STS pour le modèle de basepearsonr = sts_benchmark(base_model)print("STS Benachmark: " + str(pearsonr))

STS Benchmark (dev) : 0,8325

Affinage du modèle

La prochaine étape consiste à construire l’architecture du modèle siamois en utilisant le modèle de base et à l’affiner avec nos données spécifiques au domaine.

# Charge le modèle d'embedding de mots pré-entraînéembedding_layer = hub.load(base_model_url)# Crée une couche Keras à partir du modèle d'embedding chargéshared_embedding_layer = hub.KerasLayer(embedding_layer, trainable=True)# Définit les entrées du modèleleft_input = keras.Input(shape=(), dtype=tf.string)right_input = keras.Input(shape=(), dtype=tf.string)# Passe les entrées à travers la couche d'embedding partagéeembedding_left_output = shared_embedding_layer(left_input)embedding_right_output = shared_embedding_layer(right_input)# Calcule la similarité cosinus entre les vecteurs d'embeddingcosine_similarity = tf.keras.layers.Dot(axes=-1, normalize=True)(    [embedding_left_output, embedding_right_output])# Convertit la similarité cosinus en distance angulairepi = 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)# Emballe le modèleencoder = tf.keras.Model([left_input, right_input], acos_distance)# Compile le modèleencoder.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(),    ],)# Affiche le résumé du modèleencoder.summary()

Ajuster le modèle

# Définit le callback d'arrêt précoceearly_stop = keras.callbacks.EarlyStopping(    monitor="loss", patience=3, min_delta=0.001)# Définit le callback TensorBoardlogdir = os.path.join(".", "logs/fit/" + datetime.now().strftime("%Y%m%d-%H%M%S"))tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)# Entrée du modèleleft_inputs, right_inputs, similarity = process_model_input(data)# Entraîne le modèle d'encodeurhistory = encoder.fit(    [left_inputs, right_inputs],    similarity,    batch_size=8,    epochs=20,    validation_split=0.2,    callbacks=[early_stop, tensorboard_callback],)# Entrée du modèleinputs = keras.Input(shape=[], dtype=tf.string)# Passe l'entrée à travers la couche d'embeddingembedding = hub.KerasLayer(embedding_layer)(inputs)# Crée le modèle affinétuned_model = keras.Model(inputs=inputs, outputs=embedding)

Évaluation

Maintenant que nous avons le modèle affiné, réévaluons-le et comparons les résultats à ceux du modèle de base.

# Crée des embeddings pour les phrases de la liste test_text. # La fonction np.array() est utilisée pour convertir le résultat en un tableau numpy.# La fonction .tolist() est utilisée pour convertir le tableau numpy en une liste, ce qui peut être plus facile à manipuler.vectors = np.array(tuned_model.predict(test_text)).tolist()# Appelle la fonction plot_similarity pour créer un graphique de similarité.plot_similarity(test_text, vectors, 90, "modèle affiné")# Calcule le score STS benchmark pour le modèle affinépearsonr = sts_benchmark(tuned_model)print("STS Benachmark: " + str(pearsonr))

STS Benchmark (dev) : 0.8349

Sur la base de l’affinage du modèle sur l’ensemble de données relativement petit, le score STS benchmark est comparable à celui du modèle de référence, ce qui indique que le modèle affiné présente toujours une généralisabilité. Cependant, la visualisation de la similarité montre des scores de similarité renforcés entre les titres similaires et une réduction des scores pour les titres différents.

Réflexions finales

L’affinage des modèles NLP pré-entraînés pour l’adaptation au domaine est une technique puissante pour améliorer leurs performances et leur précision dans des contextes spécifiques. En utilisant des ensembles de données de qualité spécifiques au domaine et en exploitant des réseaux neuronaux siamois, nous pouvons améliorer la capacité du modèle à capturer la similarité sémantique.

Ce tutoriel a fourni un guide étape par étape du processus d’affinage, en utilisant le modèle Universal Sentence Encoder (USE) comme exemple. Nous avons exploré le cadre théorique, la préparation des données, l’évaluation du modèle de référence et le processus réel d’affinage. Les résultats ont démontré l’efficacité de l’affinage pour renforcer les scores de similarité dans un domaine spécifique.

En suivant cette approche et en l’adaptant à votre domaine spécifique, vous pouvez exploiter pleinement le potentiel des modèles NLP pré-entraînés et obtenir de meilleurs résultats dans vos tâches de traitement du langage naturel.

Merci de votre lecture. Si vous avez des commentaires, n’hésitez pas à commenter cet article, à me contacter sur LinkedIn ou à m’envoyer un e-mail (smhkapadia[at]gmail.com)

Si vous avez apprécié cet article, visitez mes autres articles

Évaluer les modèles de sujets : Latent Dirichlet Allocation (LDA)

Un guide étape par étape pour construire des modèles de sujets interprétables

towardsdatascience.com

L’évolution du traitement du langage naturel

Une perspective historique sur le développement des modèles de langage

IPGirl.com

Système de recommandation en Python : LightFM

Un guide étape par étape pour construire un système de recommandation en Python en utilisant LightFM

towardsdatascience.com

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!