Analyse de données et NLP avec les LLM

Analyse de données et NLP avec les LLM

Introduction

Les modèles de langage peuvent être utilisés pour effectuer des analyses sophistiquées de données textuelles et non-textuelles. Ce tutoriel explore les différentes façons d’utiliser les LLM pour l’analyse de données et le traitement du langage naturel.

Analyse de données avec LLM

1. Analyse de données structurées

import pandas as pd
from openai import OpenAI
import json

class DataAnalyzer:
    def __init__(self, api_key):
        self.client = OpenAI(api_key=api_key)
    
    def analyze_dataframe(self, df, analysis_type="general"):
        # Convertir le DataFrame en description statistique
        stats = df.describe().to_json()
        sample = df.head().to_json()
        
        prompt = f"""
        Analyse les données suivantes :
        
        Statistiques : {stats}
        Échantillon : {sample}
        
        Type d'analyse demandée : {analysis_type}
        
        Fournis :
        1. Un résumé des tendances principales
        2. Des insights clés
        3. Des recommandations d'analyse supplémentaires
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.3
        )
        
        return response.choices[0].message.content

2. Analyse de séries temporelles

class TimeSeriesAnalyzer:
    def __init__(self, api_key):
        self.client = OpenAI(api_key=api_key)
    
    def analyze_trends(self, data, time_column, value_column):
        # Calculer les statistiques de base
        stats = {
            "mean": data[value_column].mean(),
            "std": data[value_column].std(),
            "trend": "upward" if data[value_column].iloc[-1] > data[value_column].iloc[0] else "downward"
        }
        
        prompt = f"""
        Analyse la série temporelle suivante :
        
        Statistiques : {json.dumps(stats)}
        Période : {data[time_column].min()} à {data[time_column].max()}
        
        Fournis :
        1. Analyse de la tendance
        2. Points d'inflexion potentiels
        3. Recommandations pour l'analyse
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.3
        )
        
        return response.choices[0].message.content

Traitement du langage naturel

1. Analyse de sentiment

class SentimentAnalyzer:
    def __init__(self, api_key):
        self.client = OpenAI(api_key=api_key)
    
    def analyze_sentiment(self, text, detailed=False):
        prompt = f"""
        Analyse le sentiment du texte suivant :
        
        Texte : {text}
        
        {'Fournis une analyse détaillée incluant :' if detailed else 'Fournis :'}
        1. Sentiment global (positif/négatif/neutre)
        {'2. Éléments positifs' if detailed else ''}
        {'3. Éléments négatifs' if detailed else ''}
        {'4. Suggestions d\'amélioration' if detailed else ''}
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.3
        )
        
        return response.choices[0].message.content

2. Extraction d’entités

class EntityExtractor:
    def __init__(self, api_key):
        self.client = OpenAI(api_key=api_key)
    
    def extract_entities(self, text, entity_types=None):
        if entity_types is None:
            entity_types = ["personnes", "organisations", "lieux", "dates"]
        
        prompt = f"""
        Extrais les entités suivantes du texte : {', '.join(entity_types)}
        
        Texte : {text}
        
        Fournis les résultats au format JSON avec les catégories suivantes :
        {json.dumps({et: [] for et in entity_types}, indent=2)}
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.3
        )
        
        return json.loads(response.choices[0].message.content)

3. Classification de texte

class TextClassifier:
    def __init__(self, api_key):
        self.client = OpenAI(api_key=api_key)
    
    def classify_text(self, text, categories, examples=None):
        prompt = f"""
        Classifie le texte suivant dans l'une des catégories : {', '.join(categories)}
        
        Texte : {text}
        
        {'Exemples de classification :' if examples else ''}
        {self._format_examples(examples) if examples else ''}
        
        Fournis :
        1. La catégorie la plus appropriée
        2. Un score de confiance (0-1)
        3. Une justification
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.3
        )
        
        return response.choices[0].message.content
    
    def _format_examples(self, examples):
        formatted = ""
        for category, texts in examples.items():
            formatted += f"\n{category}:\n"
            for text in texts:
                formatted += f"- {text}\n"
        return formatted

Applications pratiques

1. Analyse de feedback clients

class FeedbackAnalyzer:
    def __init__(self, api_key):
        self.sentiment_analyzer = SentimentAnalyzer(api_key)
        self.entity_extractor = EntityExtractor(api_key)
    
    def analyze_feedback(self, feedback_text):
        # Analyse de sentiment
        sentiment = self.sentiment_analyzer.analyze_sentiment(feedback_text, detailed=True)
        
        # Extraction d'entités
        entities = self.entity_extractor.extract_entities(feedback_text)
        
        # Analyse globale
        prompt = f"""
        Analyse le feedback client suivant :
        
        Texte : {feedback_text}
        Sentiment : {sentiment}
        Entités identifiées : {json.dumps(entities, indent=2)}
        
        Fournis :
        1. Points clés du feedback
        2. Actions recommandées
        3. Priorité (haute/moyenne/basse)
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.3
        )
        
        return {
            "sentiment_analysis": sentiment,
            "entities": entities,
            "recommendations": response.choices[0].message.content
        }

2. Analyse de données marketing

class MarketingAnalyzer:
    def __init__(self, api_key):
        self.client = OpenAI(api_key=api_key)
    
    def analyze_campaign(self, campaign_data):
        prompt = f"""
        Analyse les données de la campagne marketing suivante :
        
        Données : {json.dumps(campaign_data, indent=2)}
        
        Fournis :
        1. Performance globale
        2. Segments performants
        3. Opportunités d'amélioration
        4. Recommandations pour la prochaine campagne
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.3
        )
        
        return response.choices[0].message.content

Optimisation et bonnes pratiques

1. Gestion du contexte

class ContextManager:
    def __init__(self, max_tokens=4000):
        self.max_tokens = max_tokens
        self.context = []
    
    def add_to_context(self, item):
        self.context.append(item)
        self._trim_context()
    
    def _trim_context(self):
        # Estimation simple du nombre de tokens
        total_tokens = sum(len(str(item).split()) for item in self.context)
        
        while total_tokens > self.max_tokens and self.context:
            removed = self.context.pop(0)
            total_tokens -= len(str(removed).split())
    
    def get_context(self):
        return self.context

2. Mise en cache des résultats

class ResultCache:
    def __init__(self, ttl=3600):  # TTL en secondes
        self.cache = {}
        self.ttl = ttl
    
    def get(self, key):
        if key in self.cache:
            result = self.cache[key]
            if time.time() - result['timestamp'] < self.ttl:
                return result['data']
            else:
                del self.cache[key]
        return None
    
    def set(self, key, data):
        self.cache[key] = {
            'data': data,
            'timestamp': time.time()
        }

Exemples d’utilisation

1. Analyse de données de ventes

# Exemple d'utilisation
sales_data = pd.DataFrame({
    'date': pd.date_range(start='2023-01-01', periods=100),
    'product': ['A', 'B', 'C'] * 34,
    'sales': np.random.normal(1000, 200, 100)
})

analyzer = DataAnalyzer(api_key="votre_clé_api")
analysis = analyzer.analyze_dataframe(sales_data, analysis_type="sales_trends")
print(analysis)

2. Analyse de sentiment sur les réseaux sociaux

# Exemple d'utilisation
tweets = [
    "Super produit, je recommande !",
    "Déçu de la qualité...",
    "Service client excellent"
]

analyzer = SentimentAnalyzer(api_key="votre_clé_api")
for tweet in tweets:
    sentiment = analyzer.analyze_sentiment(tweet, detailed=True)
    print(f"Tweet: {tweet}")
    print(f"Analyse: {sentiment}\n")

Conclusion

Les LLM offrent des capacités puissantes pour l’analyse de données et le traitement du langage naturel. En utilisant les techniques présentées dans ce tutoriel, vous pouvez :

• Analyser des données structurées et non structurées
• Extraire des insights pertinents
• Classifier et catégoriser du texte
• Analyser les sentiments et les émotions
• Optimiser les performances de vos analyses

Dans le prochain tutoriel, nous explorerons l’utilisation des LLM pour la génération de contenu et la création d’applications créatives.