Recherche et analyse d'information avec les LLM
Recherche et analyse d’information avec les LLM
Introduction
Les modèles de langage peuvent être utilisés pour créer des systèmes de recherche intelligents et des outils d’analyse d’information sophistiqués. Ce tutoriel explore les différentes façons d’implémenter ces fonctionnalités avec les LLM.
Types de recherche et d’analyse
1. Recherche sémantique
- Recherche par concepts
- Recherche par contexte
- Recherche par similarité
- Recherche par relations
- Recherche par intention
2. Analyse d’information
- Analyse de documents
- Analyse de données
- Analyse de tendances
- Analyse de sentiment
- Analyse de contexte
3. Extraction de connaissances
- Extraction d’entités
- Extraction de relations
- Extraction de faits
- Extraction de concepts
- Extraction de résumés
Implémentation
1. Système de recherche sémantique
from openai import OpenAI
import json
from typing import List, Dict, Any
import numpy as np
class SemanticSearchSystem:
def __init__(self, api_key: str):
self.client = OpenAI(api_key=api_key)
def search(self, query: str, documents: List[Dict[str, Any]],
search_type: str = "semantic") -> List[Dict[str, Any]]:
prompt = self._create_search_prompt(query, documents, search_type)
response = self.client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "Tu es un expert en recherche sémantique."},
{"role": "user", "content": prompt}
],
temperature=0.3
)
return json.loads(response.choices[0].message.content)
def _create_search_prompt(self, query: str, documents: List[Dict[str, Any]],
search_type: str) -> str:
return f"""
Effectue une recherche {search_type} pour la requête suivante :
Requête : {query}
Documents : {json.dumps(documents, indent=2)}
Pour chaque résultat, fournis :
1. Le document pertinent
2. Le score de pertinence
3. Les raisons de la pertinence
4. Les extraits pertinents
Réponds au format JSON.
"""2. Analyseur d’information
class InformationAnalyzer:
def __init__(self, api_key: str):
self.client = OpenAI(api_key=api_key)
def analyze_information(self, information: Dict[str, Any],
analysis_type: str = "document") -> Dict[str, Any]:
prompt = self._create_analysis_prompt(information, analysis_type)
response = self.client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "Tu es un expert en analyse d'information."},
{"role": "user", "content": prompt}
],
temperature=0.3
)
return json.loads(response.choices[0].message.content)
def _create_analysis_prompt(self, information: Dict[str, Any],
analysis_type: str) -> str:
return f"""
Analyse l'information suivante de type {analysis_type} :
Information : {json.dumps(information, indent=2)}
Fournis :
1. L'analyse détaillée
2. Les points clés
3. Les insights
4. Les recommandations
Réponds au format JSON.
"""3. Extracteur de connaissances
class KnowledgeExtractor:
def __init__(self, api_key: str):
self.client = OpenAI(api_key=api_key)
def extract_knowledge(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 de connaissances."},
{"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 connaissances 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. Moteur de recherche intelligent
class IntelligentSearchEngine:
def __init__(self, api_key: str):
self.search_system = SemanticSearchSystem(api_key)
self.information_analyzer = InformationAnalyzer(api_key)
self.knowledge_extractor = KnowledgeExtractor(api_key)
def search_and_analyze(self, query: str, documents: List[Dict[str, Any]]) -> Dict[str, Any]:
# Recherche sémantique
search_results = self.search_system.search(query, documents)
# Analyse des résultats
analysis_results = []
for result in search_results:
analysis = self.information_analyzer.analyze_information(result)
analysis_results.append(analysis)
# Extraction de connaissances
knowledge_results = []
for result in search_results:
knowledge = self.knowledge_extractor.extract_knowledge(result["content"])
knowledge_results.append(knowledge)
return {
"search_results": search_results,
"analysis_results": analysis_results,
"knowledge_results": knowledge_results,
"insights": self._generate_insights(search_results, analysis_results, knowledge_results)
}
def _generate_insights(self, search_results: List[Dict[str, Any]],
analysis_results: List[Dict[str, Any]],
knowledge_results: List[Dict[str, Any]]) -> Dict[str, Any]:
prompt = f"""
Génère des insights basés sur les résultats de recherche et d'analyse :
Résultats de recherche : {json.dumps(search_results, indent=2)}
Résultats d'analyse : {json.dumps(analysis_results, indent=2)}
Résultats d'extraction : {json.dumps(knowledge_results, 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 d'information."},
{"role": "user", "content": prompt}
],
temperature=0.3
)
return json.loads(response.choices[0].message.content)2. Analyseur de données avancé
class AdvancedDataAnalyzer:
def __init__(self, api_key: str):
self.information_analyzer = InformationAnalyzer(api_key)
self.knowledge_extractor = KnowledgeExtractor(api_key)
def analyze_data(self, data: Dict[str, Any], analysis_type: str = "comprehensive") -> Dict[str, Any]:
# Analyse d'information
information_analysis = self.information_analyzer.analyze_information(
data,
"data_analysis"
)
# Extraction de connaissances
knowledge_extraction = self.knowledge_extractor.extract_knowledge(
json.dumps(data),
"patterns"
)
return {
"information_analysis": information_analysis,
"knowledge_extraction": knowledge_extraction,
"recommendations": self._generate_recommendations(
information_analysis,
knowledge_extraction
)
}
def _generate_recommendations(self, information_analysis: Dict[str, Any],
knowledge_extraction: Dict[str, Any]) -> Dict[str, Any]:
prompt = f"""
Génère des recommandations basées sur l'analyse d'information et l'extraction de connaissances :
Analyse d'information : {json.dumps(information_analysis, indent=2)}
Extraction de connaissances : {json.dumps(knowledge_extraction, indent=2)}
Fournis :
1. Les recommandations principales
2. Les actions suggérées
3. Les améliorations possibles
4. Les priorités
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 données."},
{"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. Gestion de la qualité
class QualityManager:
def __init__(self):
self.quality_metrics = {
"accuracy": 0,
"relevance": 0,
"completeness": 0,
"consistency": 0
}
def update_metrics(self, result_data: Dict[str, Any]):
self.quality_metrics["accuracy"] = self._calculate_accuracy(result_data)
self.quality_metrics["relevance"] = self._calculate_relevance(result_data)
self.quality_metrics["completeness"] = self._calculate_completeness(result_data)
self.quality_metrics["consistency"] = self._calculate_consistency(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 de recherche
class SearchAnalytics:
def __init__(self):
self.metrics = {
"total_searches": 0,
"success_rate": 0,
"average_time": 0,
"user_satisfaction": 0
}
def update_metrics(self, search_data: Dict[str, Any]):
self.metrics["total_searches"] += 1
self.metrics["success_rate"] = self._calculate_success_rate()
self.metrics["average_time"] = self._update_average(
self.metrics["average_time"],
search_data["time"]
)
self.metrics["user_satisfaction"] = self._calculate_satisfaction()
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 la recherche et l’analyse d’information. En utilisant les techniques présentées dans ce tutoriel, vous pouvez :
- Créer des systèmes de recherche sémantique
- Analyser l’information de manière sophistiquée
- Extraire des connaissances pertinentes
- Optimiser les résultats de recherche
- Gérer la qualité des résultats
- Suivre et améliorer les performances
Dans le prochain tutoriel, nous explorerons l’utilisation des LLM pour la création d’applications de génération de code et d’assistance au développement.