Implémentation de la détection de sujets avec OpenAI

La détection de sujet (topic detection) est une capacité fondamentale en traitement du langage naturel (natural language processing) qui permet aux systèmes d'identifier automatiquement le sujet principal d'un texte. Alors que les organisations traitent des volumes croissants de données textuelles, la capacité à catégoriser précisément le contenu devient essentielle pour la gestion de contenu, les systèmes de recommandation et la recherche d'information.

Dans ce guide, nous explorerons comment implémenter une détection de sujet robuste en utilisant les puissants modèles de langage d'OpenAI. Nous passerons en revue une implémentation pratique qui a atteint une précision de 88,1 % lors de nos tests de benchmark, en vous fournissant le code et les informations nécessaires pour intégrer cette capacité dans vos propres applications.

Pourquoi la Détection de Sujet est Importante

La détection de sujet permet plusieurs capacités critiques dans les applications modernes :

• Organisation et récupération de contenu plus efficaces
• Expériences utilisateur améliorées grâce à de meilleures recommandations de contenu
• Fonctionnalité de recherche améliorée sur de grandes collections de documents
• Modération et filtrage automatisés du contenu
• Informations basées sur les données concernant les tendances de contenu et les intérêts des utilisateurs

Pour les systèmes basés sur l'IA, détecter avec précision le sujet de la requête d'un utilisateur aide à acheminer les requêtes vers des modèles spécialisés ou des bases de connaissances, fournissant des réponses plus pertinentes contextuellement. Ceci est particulièrement précieux pour les déploiements en entreprise où comprendre l'intention de l'utilisateur à travers divers domaines, du support technique aux demandes de produits en passant par les questions de politique, peut améliorer considérablement la qualité des réponses et la satisfaction des utilisateurs.

Même de petites améliorations dans la précision de la détection de sujet peuvent se traduire par des avantages opérationnels significatifs pour les entreprises traitant quotidiennement des milliers ou des millions de documents texte.

Le Jeu de Données (Dataset)

Notre implémentation a été testée sur un jeu de données diversifié comprenant 2 926 échantillons de texte répartis dans 14 catégories thématiques distinctes :

• Santé et Médecine (235 échantillons)
• Éducation (216 échantillons)
• Technologie (209 échantillons)
• Politique (207 échantillons)
• Alimentation et Cuisine (207 échantillons)
• Psychologie et Développement Personnel (206 échantillons)
• Environnement et Climat (206 échantillons)
• Divertissement (204 échantillons)
• Affaires et Entrepreneuriat (204 échantillons)
• Voyage et Tourisme (203 échantillons)
• Science et Espace (202 échantillons)
• Sports (201 échantillons)
• Histoire (200 échantillons)
• Finance et Économie (185 échantillons)

Exemples de Textes du Jeu de Données

Le tableau ci-dessous fournit un exemple représentatif de chaque catégorie de sujet :

Implémentation de la Détection de Sujet avec OpenAI

Plongeons dans l'implémentation pratique de la détection de sujet en utilisant les modèles d'OpenAI. Cette approche a atteint une précision impressionnante de 88,1 % lors de nos tests de benchmark.

Démarrer avec l'API d'OpenAI

Pour implémenter la détection de sujet avec OpenAI, vous devrez :

1. Créer un compte OpenAI et obtenir une clé API depuis la plateforme OpenAI
2. Installer les dépendances requises :
   
   Copied!

   1pip install openai pandas tqdm python-dotenv

3. Configurer vos variables d'environnement en créant un fichier
   Copied!

   1.env

   avec votre clé API :
   Copied!

   1   OPENAI_API_KEY=votre-cle-api-ici

L'Implémentation

Voici l'implémentation complète que nous avons utilisée pour atteindre une précision de 88,1 % avec le modèle GPT-4 Mini d'OpenAI :

Copied!
1import os
2from tqdm import tqdm  # For progress bar visualization
3from typing import Any
4import pandas as pd	# For data manipulation
5import json
6from dotenv import load_dotenv  # For secure API key management
7import time  # For execution time measurement
8from openai import OpenAI
9
10# Load environment variables from .env file for secure API key storage
11load_dotenv()
12OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
13client = OpenAI(api_key=OPENAI_API_KEY)
14
15# Load the dataset containing text samples and their topic labels
16df = pd.read_csv(filepath_or_buffer="data/topic_detection.csv")
17# Extract unique topic labels to provide to the model
18labels = list(df["label"].unique())
19
20def openai_topic_detection(text: str) -> Any:
21	# Craft a detailed system prompt that instructs the model exactly how to perform classification
22	system_prompt = """
23	You are an expert on topic classification.
24	You will receive a text and you will need to classify this text depending on the topic it discusses.
25    
26	The list of topics to consider is the following:
27	{labels}
28    
29	You need to pick only one of the labels in the list and you need to use the exact same spelling.
30	Provide the output in a json with this structure:
31    
32	{{
33    	"class": "the label you picked with the exact same spelling as in the list"
34	}}
35    
36	Only answer with the json output. Do not provide any other output.
37	MAKE SURE THE LABEL HAS THE EXACT SPELLING AS IN THE LIST OF POSSIBLE LABELS
38	Example correct output:
39    
40	{{"class": "ACLASS"}}
41    
42	"""
43
44	# Call the OpenAI API with our carefully crafted prompt
45	completions = client.chat.completions.create(
46    	model="gpt-4o-mini",  # Using GPT-4o Mini for optimal accuracy/speed balance
47    	messages=[
48        	{
49            	"role": "system",  # Using system role for system instructions (corrected from developer for clarity, though OpenAI API accepts custom roles)
50            	"content": system_prompt.format(labels=labels),  # Dynamically insert our topic labels
51        	},
52        	{
53            	"role": "user",  # User role contains the text to be classified
54            	"content": text,
55        	},
56    	],
57	)
58	# Parse the JSON response using eval() - in production, consider using json.loads() for safety
59	response = eval(completions.choices[0].message.content)
60	return response["class"]  # Extract just the class label from the response
61
62def main(df: pd.DataFrame):
63	# Initialize lists to store results
64	execution = list()  # Will store execution times
65	topic_detected = list()  # Will store detected topics
66    
67	# Process each text sample with a progress bar
68	for _, row in tqdm(df.iterrows(), total=len(df), desc="OpenAI Topic Detection"):
69    	text = row["text"]
70    	# Measure execution time for each classification
71    	start = time.time()
72    	topic = openai_topic_detection(text=text)
73    	end = time.time()
74    	exec = end - start
75   	 
76    	# Store results
77    	topic_detected.append(topic)
78    	execution.append(exec)
79    
80	# Add results as new columns to the dataframe
81	df["execution_time (s)"] = execution
82	df["topic_detected"] = topic_detected
83
84	# Save the results to a CSV file for analysis
85	df.to_csv(path_or_buf="data/openai_topic_detection.csv", index_label=False)
86
87if __name__ == "__main__":
88	main(df=df)  # Execute the main function when script is run directly
89

Détails Clés de l'Implémentation

Décomposons les éléments clés qui rendent cette implémentation réussie :

1. Ingénierie Précise du Prompt Système (System Prompt Engineering)

Le prompt système est crucial pour atteindre une haute précision. Notre implémentation :

• Établit le modèle comme un "expert en classification de sujets"
• Définit clairement la tâche : classifier le texte en fonction du sujet
• Fournit la liste exacte des sujets possibles de manière dynamique
• Impose un formatage de sortie strict en JSON
• Souligne l'importance de l'orthographe exacte dans les étiquettes
• Inclut un exemple du format de sortie attendu

Cette ingénierie de prompt minutieuse garantit que le modèle comprend exactement ce qui est attendu et produit des résultats cohérents et analysables.

2. Sortie JSON Structurée

En demandant une réponse JSON structurée avec un schéma spécifique :

Copied!
1{
2	"class": "l'étiquette que vous avez choisie"
3}
4

Nous nous assurons :

• De réponses cohérentes et facilement analysables
• D'aucune explication ou texte superflu
• De l'extraction directe du résultat de la classification

La fonction

1eval()

1response["class"]

1json.loads()

3. Messagerie Basée sur les Rôles (Role-Based Messaging)

Notre implémentation utilise deux rôles distincts dans l'appel API :

• Copied!

  1"role": "system"

  (ou
  Copied!

  1"developer"

  comme dans le code original) pour le prompt système qui définit la tâche
• Copied!

  1"role": "user"

  pour le texte à classifier

Cette séparation aide le modèle à distinguer les instructions du contenu à analyser.

4. Suivi des Performances

L'implémentation inclut un suivi intégré des performances :

• Mesure du temps d'exécution pour chaque classification
• Suivi de la progression avec tqdm
• Stockage des résultats pour une analyse ultérieure

Cela nous a permis de mesurer avec précision le temps de traitement moyen de 0,65 seconde rapporté dans notre benchmark.

Adapter l'Implémentation à Vos Besoins

Pour utiliser ce code pour vos propres besoins de détection de sujet :

1. Préparez votre jeu de données : Assurez-vous que vos données ont une colonne "text" contenant le contenu à classifier et une colonne "label" avec la vérité terrain (si vous évaluez les performances).

2. Personnalisez la liste des sujets : Si vous avez un ensemble fixe de sujets, vous pouvez les coder en dur au lieu de les extraire du jeu de données :

Copied!
1   labels = ["Technologie", "Santé & Médecine", "Finance & Économie", "Politique", ...]
2

3. Ajustez le modèle : Bien que nous ayons utilisé "gpt-4o-mini" pour notre benchmark, vous pouvez expérimenter avec d'autres modèles OpenAI :

Copied!
1   model="gpt-4" # Pour la plus haute précision mais un coût plus élevé
2   model="gpt-3.5-turbo" # Pour un coût inférieur avec une précision raisonnable
3

Résultats des Performances

Lors de nos tests de benchmark, cette implémentation OpenAI a atteint :

• 88,1 % de précision dans la classification des sujets - identifiant correctement les sujets dans près de 9 échantillons de texte sur 10
• 0,650 seconde de temps de traitement moyen par échantillon de texte

Cela représente un excellent équilibre entre précision et vitesse pour la plupart des applications pratiques.

Conclusion

L'implémentation de la détection de sujet avec les modèles d'OpenAI offre un moyen puissant de catégoriser automatiquement le contenu textuel avec une grande précision. L'implémentation que nous avons partagée a atteint une précision de 88,1 % sur un jeu de données diversifié de sujets, la rendant adaptée à un large éventail d'applications allant de la gestion de contenu à la classification de l'intention utilisateur.

En suivant l'approche décrite dans ce guide, vous pouvez intégrer rapidement des capacités sophistiquées de détection de sujet dans vos propres applications, en exploitant la puissance des modèles de langage d'OpenAI pour comprendre et catégoriser le contenu textuel.

Que vous construisiez un système de recommandation de contenu, amélioriez une fonctionnalité de recherche ou développiez un assistant IA qui doit comprendre les requêtes des utilisateurs, cette implémentation fournit une base solide pour une détection de sujet précise.