Introduction aux text embeddings avec l’API OpenAI

Les text embeddings sont un outil essentiel en traitement automatique du langage naturel (NLP). Il s’agit de représentations numériques du texte où chaque mot ou expression est encodé sous forme de vecteur dense de nombres réels.

Leur principal atout réside dans leur capacité à capturer les significations sémantiques et les relations entre mots ou expressions, ce qui permet aux machines de mieux comprendre et traiter le langage humain.

Les text embeddings sont incontournables pour la classification de texte, la recherche d’information et la détection de similarité sémantique.

OpenAI, reconnu pour ses contributions majeures à l’intelligence artificielle, recommande actuellement d’utiliser le modèle Ada V2 pour créer des embeddings de texte. Issu de la famille des modèles GPT, il a été entraîné pour saisir encore mieux le sens contextuel et les associations présentes dans le texte.

Si vous ne connaissez pas encore l’API d’OpenAI ni le package Python openai, nous vous recommandons de lire Using GPT-3.5 and GPT-4 via the OpenAI API in Python avant de poursuivre. Ce guide vous aidera à configurer vos comptes et à comprendre les avantages de l’utilisation de l’API.

Ce tutoriel mobilise également le clustering, une technique d’apprentissage automatique qui consiste à regrouper des instances similaires. Si vous n’êtes pas à l’aise avec le clustering, en particulier le k-means, consultez Introduction to k-Means Clustering with scikit-learn in Python.

À quoi servent les text embeddings ?

Les embeddings de texte couvrent de nombreux cas d’usage, notamment :

• Classification de texte. Ils facilitent la création de modèles précis pour l’analyse de sentiment ou l’identification de sujets.
• Recherche d’information. Ils permettent de retrouver des contenus pertinents pour une requête donnée, à la manière d’un moteur de recherche.
• Détection de similarité sémantique. Les embeddings aident à identifier et quantifier la similarité sémantique entre des extraits de texte.
• Systèmes de recommandation. Ils améliorent la qualité des recommandations en tenant compte des préférences utilisateur à partir de leurs interactions textuelles.
• Génération de texte. Ils contribuent à produire des textes plus cohérents et contextuellement pertinents.
• Traduction automatique. Les embeddings capturent des significations sémantiques interlangues, ce qui peut améliorer la qualité des traductions automatiques.

Mise en place

Plusieurs packages Python sont nécessaires pour travailler avec les embeddings de texte :

• os : bibliothèque standard Python pour interagir avec le système d’exploitation.
• openai : client Python pour interagir avec l’API OpenAI.
• scipy.spatial.distance : fonctions pour calculer des distances entre points de données.
• sklean.cluster.KMeans : utilisé pour effectuer un clustering KMeans.
• umap.UMAP : technique de réduction de dimension pour des données à haute dimension.

Avant de les utiliser, installez openai, scipy, plotly sklearn et umap avec la commande suivante. Le code complet est disponible dans ce DataLab workbook.

pip install -U openai, scipy, plotly-express, scikit-learn, umap-learnPropulsé par

Après exécution, importez les bibliothèques comme suit :

import os
import openai
from scipy.spatial import distance
import plotly.express as px
from sklearn.cluster import KMeans
from umap import UMAPPropulsé par

Configurez ensuite la clé d’API OpenAI :

openai.api_key = "<YOUR_API_KEY_HERE>"Propulsé par

Remarque : vous devez utiliser votre propre clé d’API. Celle du code source n’est pas disponible et était réservée à un usage individuel.

Patron de code pour appeler GPT via l’API

La fonction utilitaire suivante permet de générer l’embedding d’une ligne de texte via l’API OpenAI. Le code utilise la version ada 2 existante pour produire les embeddings.

def get_embedding(text_to_embed):
	# Embed a line of text
	response = openai.Embedding.create(
    	model= "text-embedding-ada-002",
    	input=[text_to_embed]
	)
	# Extract the AI output embedding as a list of floats
	embedding = response["data"][0]["embedding"]
    
	return embeddingPropulsé par

À propos du jeu de données

Dans cette section, nous utiliserons les avis Amazon sur les instruments de musique disponibles gratuitement sur Kaggle. Les données peuvent aussi être téléchargées depuis mon compte Github comme suit :

import pandas as pd

data_URL =  "https://raw.githubusercontent.com/keitazoumana/Experimentation-Data/main/Musical_instruments_reviews.csv"

review_df = pd.read_csv(data_URL)
review_df.head()Propulsé par

Parmi toutes les colonnes, seule la colonne reviewText nous intéresse.

review_df = review_df[['reviewText']]
print("Data shape: {}".format(review_df.shape))
display(review_df.head())Propulsé par

Data shape: (10261, 1)
Propulsé par

Le jeu de données contient de très nombreux avis. Pour maîtriser les coûts, nous n’utiliserons que 100 lignes sélectionnées aléatoirement.

Nous pouvons maintenant générer les embeddings pour chaque ligne de l’échantillon en appliquant la fonction précédente via une expression lambda :

review_df = review_df.sample(100)
review_df["embedding"] = review_df["reviewText"].astype(str).apply(get_embedding)

# Make the index start from 0
review_df.reset_index(drop=True)

review_df.head(10)
Propulsé par

10 premières lignes des avis et de leurs embeddings

Comprendre la similarité de texte

Pour illustrer la similarité sémantique, prenons deux avis qui véhiculent un ressenti proche :

« Ce produit est fantastique ! »

« Il a vraiment dépassé mes attentes ! »

Avec pdist() de scipy.spatial.distance, on peut calculer la distance euclidienne entre leurs embeddings.

La distance euclidienne correspond à la racine carrée de la somme des carrés des différences entre les deux embeddings, comme illustré ci-dessous :

Illustration de la distance euclidienne (source)

Si ces avis sont effectivement similaires, la distance devrait être relativement faible.

Considérons ensuite deux avis différents :

« Ce produit est fantastique ! »

« Je ne suis pas satisfait de l’article. »

La distance entre leurs embeddings sera nettement plus grande que celle observée pour des avis similaires.

Cas d’usage : utiliser les embeddings de texte pour une analyse par clusters

Les embeddings générés peuvent servir à réaliser une analyse par clusters, afin de regrouper les instruments de musique dont les avis se ressemblent le plus.

Plusieurs algorithmes de clustering existent : k-means, DBSCAN, clustering hiérarchique, ou modèles de mélanges gaussiens. Dans notre cas, nous utiliserons k-means. Pour une compréhension approfondie du clustering hiérarchique et de son implémentation en Python, consultez An Introduction to Hierarchical Clustering in Python.

Clustériser les textes

Avec k-means, il faut définir au préalable le nombre de clusters. Nous fixerons n_clusters à 3 :

kmeans = KMeans(n_clusters=3)
kmeans.fit(review_df["embedding"].tolist())Propulsé par

Réduire la dimension des embeddings

Les humains visualisent au mieux trois dimensions. Nous allons donc utiliser UMAP, un outil rapide et extensible de réduction de dimension.

Nous créons d’abord une instance de UMAP puis appliquons fit_transform aux embeddings pour obtenir une représentation en deux dimensions des avis, exploitable en visualisation.

reducer = UMAP()
embeddings_2d = reducer.fit_transform(review_df["embedding"].tolist())Propulsé par

Visualiser les clusters

Enfin, créons un nuage de points des embeddings en 2D. Les coordonnées x et y proviennent respectivement de embeddings_2d[: , 0] et embeddings_2d[: , 1].

Les clusters apparaîtront visuellement distincts :

fig = px.scatter(x=embeddings_2d[:, 0], y=embeddings_2d[:, 1], color=kmeans.labels_)
fig.show()Propulsé par

Visualisation des clusters

On observe trois clusters principaux, chacun avec une couleur différente. La couleur de chaque avis correspond à l’étiquette de cluster attribuée par le modèle k-means. La position de chaque point reflète visuellement la proximité sémantique d’un avis par rapport aux autres.

Passez à la vitesse supérieure

Pour approfondir vos connaissances sur les text embeddings et l’API OpenAI, consultez les ressources DataCamp suivantes : Fine-Tuning GPT-3 Using the OpenAI API and Python et The OpenAI API in Python Cheat Sheet. Elles vous aideront à exploiter tout le potentiel de GPT-3 via le fine-tuning et illustrent comment utiliser l’API OpenAI et Python pour adapter ce réseau de neurones avancé à votre cas d’usage.