Traitement du langage naturel avancé avec les LLM
Traitement du langage naturel avancé avec les LLM
Introduction
Les modèles de langage peuvent être utilisés pour effectuer des tâches avancées de traitement du langage naturel (NLP). Ce tutoriel explore les différentes façons d’implémenter ces fonctionnalités avec les LLM.
Types de tâches NLP
1. Analyse de texte
- Analyse de sentiment
- Analyse de ton
- Analyse de style
- Analyse de cohérence
- Analyse de structure
2. Classification
- Classification de documents
- Classification de sentiment
- Classification de sujets
- Classification de langues
- Classification de genres
3. Extraction d’informations
- Extraction d’entités
- Extraction de relations
- Extraction de mots-clés
- Extraction de résumés
- Extraction de citations
Implémentation
1. Analyseur de texte
from openai import OpenAI
import json
from typing import List, Dict, Any
import numpy as np
class TextAnalyzer:
def __init__(self, api_key: str):
self.client = OpenAI(api_key=api_key)
def analyze_text(self, text: str, analysis_type: str = "sentiment") -> Dict[str, Any]:
prompt = self._create_analysis_prompt(text, analysis_type)
response = self.client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "Tu es un expert en analyse de texte."},
{"role": "user", "content": prompt}
],
temperature=0.3
)
return json.loads(response.choices[0].message.content)
def _create_analysis_prompt(self, text: str, analysis_type: str) -> str:
return f"""
Analyse le texte suivant de type {analysis_type} :
Texte : {text}
Fournis :
1. L'analyse détaillée
2. Les points clés
3. Les insights
4. Les recommandations
Réponds au format JSON.
"""2. Classificateur de texte
class TextClassifier:
def __init__(self, api_key: str):
self.client = OpenAI(api_key=api_key)
def classify_text(self, text: str, classification_type: str = "document") -> Dict[str, Any]:
prompt = self._create_classification_prompt(text, classification_type)
response = self.client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "Tu es un expert en classification de texte."},
{"role": "user", "content": prompt}
],
temperature=0.3
)
return json.loads(response.choices[0].message.content)
def _create_classification_prompt(self, text: str, classification_type: str) -> str:
return f"""
Classifie le texte suivant de type {classification_type} :
Texte : {text}
Fournis :
1. La classification
2. Le score de confiance
3. Les caractéristiques clés
4. Les alternatives
Réponds au format JSON.
"""3. Extracteur d’informations
class InformationExtractor:
def __init__(self, api_key: str):
self.client = OpenAI(api_key=api_key)
def extract_information(self, text: str, extraction_type: str = "entities") -> Dict[str, Any]:
prompt = self._create_extraction_prompt(text, extraction_type)
response = self.client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "Tu es un expert en extraction d'informations."},
{"role": "user", "content": prompt}
],
temperature=0.3
)
return json.loads(response.choices[0].message.content)
def _create_extraction_prompt(self, text: str, extraction_type: str) -> str:
return f"""
Extrais les informations de type {extraction_type} du texte suivant :
Texte : {text}
Fournis :
1. Les éléments extraits
2. Leur contexte
3. Leur importance
4. Leurs relations
Réponds au format JSON.
"""Applications avancées
1. Analyseur de documents
class DocumentAnalyzer:
def __init__(self, api_key: str):
self.text_analyzer = TextAnalyzer(api_key)
self.text_classifier = TextClassifier(api_key)
self.information_extractor = InformationExtractor(api_key)
def analyze_document(self, document: Dict[str, Any]) -> Dict[str, Any]:
# Analyse de texte
text_analysis = self.text_analyzer.analyze_text(
document["content"],
"comprehensive"
)
# Classification
classification = self.text_classifier.classify_text(
document["content"],
"document"
)
# Extraction d'informations
information = self.information_extractor.extract_information(
document["content"],
"comprehensive"
)
return {
"text_analysis": text_analysis,
"classification": classification,
"information": information,
"insights": self._generate_insights(text_analysis, classification, information)
}
def _generate_insights(self, text_analysis: Dict[str, Any],
classification: Dict[str, Any],
information: Dict[str, Any]) -> Dict[str, Any]:
prompt = f"""
Génère des insights basés sur l'analyse du document :
Analyse de texte : {json.dumps(text_analysis, indent=2)}
Classification : {json.dumps(classification, indent=2)}
Information : {json.dumps(information, indent=2)}
Fournis :
1. Les insights principaux
2. Les patterns identifiés
3. Les connexions
4. Les recommandations
Réponds au format JSON.
"""
response = self.client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "Tu es un expert en analyse de documents."},
{"role": "user", "content": prompt}
],
temperature=0.3
)
return json.loads(response.choices[0].message.content)2. Analyseur de conversations
class ConversationAnalyzer:
def __init__(self, api_key: str):
self.text_analyzer = TextAnalyzer(api_key)
self.text_classifier = TextClassifier(api_key)
self.information_extractor = InformationExtractor(api_key)
def analyze_conversation(self, conversation: List[Dict[str, Any]]) -> Dict[str, Any]:
# Analyse des messages
message_analyses = []
for message in conversation:
analysis = self.text_analyzer.analyze_text(
message["content"],
"sentiment"
)
message_analyses.append(analysis)
# Classification des messages
message_classifications = []
for message in conversation:
classification = self.text_classifier.classify_text(
message["content"],
"intent"
)
message_classifications.append(classification)
# Extraction d'informations
conversation_information = self.information_extractor.extract_information(
" ".join([msg["content"] for msg in conversation]),
"comprehensive"
)
return {
"message_analyses": message_analyses,
"message_classifications": message_classifications,
"conversation_information": conversation_information,
"insights": self._generate_insights(
message_analyses,
message_classifications,
conversation_information
)
}
def _generate_insights(self, message_analyses: List[Dict[str, Any]],
message_classifications: List[Dict[str, Any]],
conversation_information: Dict[str, Any]) -> Dict[str, Any]:
prompt = f"""
Génère des insights basés sur l'analyse de la conversation :
Analyses des messages : {json.dumps(message_analyses, indent=2)}
Classifications des messages : {json.dumps(message_classifications, indent=2)}
Information de la conversation : {json.dumps(conversation_information, indent=2)}
Fournis :
1. Les insights principaux
2. Les patterns de conversation
3. Les tendances
4. Les recommandations
Réponds au format JSON.
"""
response = self.client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "Tu es un expert en analyse de conversations."},
{"role": "user", "content": prompt}
],
temperature=0.3
)
return json.loads(response.choices[0].message.content)Optimisation et personnalisation
1. Gestionnaire de contexte
class ContextManager:
def __init__(self):
self.context = {}
def update_context(self, context_data: Dict[str, Any]):
self.context.update(context_data)
def get_context(self) -> Dict[str, Any]:
return self.context
def clear_context(self):
self.context = {}
def get_context_report(self) -> Dict[str, Any]:
return {
"context": self.context,
"summary": self._generate_summary(),
"recommendations": self._generate_recommendations()
}2. Optimiseur de résultats
class ResultOptimizer:
def __init__(self, api_key: str):
self.client = OpenAI(api_key=api_key)
def optimize_results(self, results: List[Dict[str, Any]],
optimization_criteria: Dict[str, Any]) -> List[Dict[str, Any]]:
prompt = f"""
Optimise les résultats suivants selon les critères donnés :
Résultats : {json.dumps(results, indent=2)}
Critères : {json.dumps(optimization_criteria, indent=2)}
Fournis :
1. Les résultats optimisés
2. Les améliorations apportées
3. Les métriques de performance
4. Les recommandations
Réponds au format JSON.
"""
response = self.client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "Tu es un expert en optimisation de résultats."},
{"role": "user", "content": prompt}
],
temperature=0.3
)
return json.loads(response.choices[0].message.content)Bonnes pratiques
1. Gestionnaire de qualité
class QualityManager:
def __init__(self):
self.quality_metrics = {
"accuracy": 0,
"precision": 0,
"recall": 0,
"f1_score": 0
}
def update_metrics(self, result_data: Dict[str, Any]):
self.quality_metrics["accuracy"] = self._calculate_accuracy(result_data)
self.quality_metrics["precision"] = self._calculate_precision(result_data)
self.quality_metrics["recall"] = self._calculate_recall(result_data)
self.quality_metrics["f1_score"] = self._calculate_f1_score(result_data)
def get_quality_report(self) -> Dict[str, Any]:
return {
"metrics": self.quality_metrics,
"summary": self._generate_summary(),
"recommendations": self._generate_recommendations()
}2. Analytics NLP
class NLPAnalytics:
def __init__(self):
self.metrics = {
"total_analyses": 0,
"success_rate": 0,
"average_time": 0,
"quality_score": 0
}
def update_metrics(self, analysis_data: Dict[str, Any]):
self.metrics["total_analyses"] += 1
self.metrics["success_rate"] = self._calculate_success_rate()
self.metrics["average_time"] = self._update_average(
self.metrics["average_time"],
analysis_data["time"]
)
self.metrics["quality_score"] = self._calculate_quality_score()
def get_analytics_report(self) -> Dict[str, Any]:
return {
"metrics": self.metrics,
"trends": self._calculate_trends(),
"recommendations": self._generate_recommendations()
}Conclusion
Les LLM offrent des capacités puissantes pour le traitement du langage naturel avancé. En utilisant les techniques présentées dans ce tutoriel, vous pouvez :
- Analyser des textes de manière sophistiquée
- Classifier des documents avec précision
- Extraire des informations pertinentes
- Analyser des conversations
- Optimiser les résultats NLP
- Gérer la qualité des analyses
- Suivre et améliorer les performances
Dans le prochain tutoriel, nous explorerons l’utilisation des LLM pour la création d’applications de recommandation et de personnalisation.