Analyse de données avec ChatGPT

Introduction

L’API ChatGPT peut être utilisée pour analyser et interpréter des données de différentes manières. Dans ce tutoriel, nous allons explorer comment utiliser ChatGPT pour l’analyse de données, la visualisation et l’interprétation des résultats.

Types d’analyses possibles

1. Analyse descriptive

   • Statistiques de base
   • Tendances et patterns
   • Résumés de données

2. Analyse prédictive

   • Prévisions
   • Détection d’anomalies
   • Classification

3. Analyse de texte

   • Analyse de sentiment
   • Extraction d’entités
   • Classification de texte

Intégration avec Python

1. Configuration de base

import openai
import pandas as pd
import numpy as np
from typing import List, Dict, Any

class ChatGPTAnalyzer:
    def __init__(self, api_key: str):
        openai.api_key = api_key
        
    def analyze_dataframe(self, df: pd.DataFrame, analysis_type: str) -> str:
        """
        Analyse un DataFrame pandas en utilisant ChatGPT
        """
        # Convertir le DataFrame en format texte
        data_description = df.describe().to_string()
        data_sample = df.head().to_string()
        
        prompt = f"""
        Analysez les données suivantes de type {analysis_type}:
        
        Description statistique:
        {data_description}
        
        Échantillon de données:
        {data_sample}
        
        Veuillez fournir:
        1. Un résumé des observations clés
        2. Les tendances principales
        3. Des recommandations basées sur les données
        """
        
        try:
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=[
                    {"role": "system", "content": "Vous êtes un expert en analyse de données."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.3
            )
            
            return response.choices[0].message.content
        except Exception as e:
            print(f"Erreur lors de l'analyse: {str(e)}")
            return None

2. Analyse de séries temporelles

class TimeSeriesAnalyzer:
    def __init__(self, api_key: str):
        self.analyzer = ChatGPTAnalyzer(api_key)
    
    def analyze_trends(self, df: pd.DataFrame, date_column: str, value_column: str) -> str:
        """
        Analyse les tendances dans une série temporelle
        """
        # Préparer les données
        df[date_column] = pd.to_datetime(df[date_column])
        df = df.sort_values(date_column)
        
        # Calculer les statistiques de base
        stats = {
            'mean': df[value_column].mean(),
            'std': df[value_column].std(),
            'min': df[value_column].min(),
            'max': df[value_column].max(),
            'trend': np.polyfit(range(len(df)), df[value_column], 1)[0]
        }
        
        prompt = f"""
        Analysez cette série temporelle:
        
        Statistiques:
        - Moyenne: {stats['mean']:.2f}
        - Écart-type: {stats['std']:.2f}
        - Minimum: {stats['min']:.2f}
        - Maximum: {stats['max']:.2f}
        - Tendance (pente): {stats['trend']:.2f}
        
        Données récentes:
        {df.tail().to_string()}
        
        Veuillez fournir:
        1. Une analyse de la tendance générale
        2. Identification des patterns saisonniers
        3. Prévisions à court terme
        4. Recommandations basées sur l'analyse
        """
        
        try:
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=[
                    {"role": "system", "content": "Vous êtes un expert en analyse de séries temporelles."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.3
            )
            
            return response.choices[0].message.content
        except Exception as e:
            print(f"Erreur lors de l'analyse: {str(e)}")
            return None

3. Analyse de texte

class TextAnalyzer:
    def __init__(self, api_key: str):
        self.analyzer = ChatGPTAnalyzer(api_key)
    
    def analyze_sentiment(self, texts: List[str]) -> List[Dict[str, Any]]:
        """
        Analyse le sentiment d'une liste de textes
        """
        results = []
        
        for text in texts:
            prompt = f"""
            Analysez le sentiment du texte suivant:
            
            "{text}"
            
            Fournissez:
            1. Le sentiment général (positif/négatif/neutre)
            2. Le score de sentiment (-1 à 1)
            3. Les mots-clés émotionnels
            4. Une brève explication
            """
            
            try:
                response = openai.ChatCompletion.create(
                    model="gpt-3.5-turbo",
                    messages=[
                        {"role": "system", "content": "Vous êtes un expert en analyse de sentiment."},
                        {"role": "user", "content": prompt}
                    ],
                    temperature=0.3
                )
                
                results.append({
                    'text': text,
                    'analysis': response.choices[0].message.content
                })
            except Exception as e:
                print(f"Erreur lors de l'analyse: {str(e)}")
                results.append({
                    'text': text,
                    'analysis': None
                })
        
        return results

Exemples d’utilisation

1. Analyse de données de ventes

# Exemple d'utilisation
import pandas as pd
from datetime import datetime, timedelta

# Créer des données de test
dates = pd.date_range(start='2023-01-01', end='2023-12-31', freq='D')
sales = np.random.normal(1000, 200, len(dates))
df = pd.DataFrame({
    'date': dates,
    'sales': sales
})

# Initialiser l'analyseur
analyzer = TimeSeriesAnalyzer('votre_clé_api')

# Analyser les tendances
analysis = analyzer.analyze_trends(df, 'date', 'sales')
print(analysis)

2. Analyse de feedback clients

# Exemple d'analyse de sentiment
texts = [
    "Le produit est excellent, je le recommande vivement !",
    "Service client décevant, réponse très lente.",
    "Bon rapport qualité-prix, mais livraison un peu lente."
]

analyzer = TextAnalyzer('votre_clé_api')
results = analyzer.analyze_sentiment(texts)

for result in results:
    print(f"\nTexte: {result['text']}")
    print(f"Analyse: {result['analysis']}")

Visualisation des résultats

1. Intégration avec Matplotlib

import matplotlib.pyplot as plt
import seaborn as sns

class DataVisualizer:
    @staticmethod
    def plot_time_series(df: pd.DataFrame, date_column: str, value_column: str):
        """
        Crée une visualisation de série temporelle
        """
        plt.figure(figsize=(12, 6))
        sns.set_style("whitegrid")
        
        plt.plot(df[date_column], df[value_column], label='Données')
        
        # Ajouter la tendance
        z = np.polyfit(range(len(df)), df[value_column], 1)
        p = np.poly1d(z)
        plt.plot(df[date_column], p(range(len(df))), "r--", label='Tendance')
        
        plt.title('Analyse de série temporelle')
        plt.xlabel('Date')
        plt.ylabel('Valeur')
        plt.legend()
        
        return plt.gcf()
    
    @staticmethod
    def plot_sentiment_distribution(results: List[Dict[str, Any]]):
        """
        Crée une visualisation de la distribution des sentiments
        """
        sentiments = []
        for result in results:
            if result['analysis']:
                # Extraire le sentiment de l'analyse
                sentiment = result['analysis'].split('\n')[0].lower()
                sentiments.append(sentiment)
        
        plt.figure(figsize=(8, 6))
        sns.countplot(x=sentiments)
        plt.title('Distribution des sentiments')
        plt.xlabel('Sentiment')
        plt.ylabel('Nombre')
        
        return plt.gcf()

Bonnes pratiques

1. Prétraitement des données

   • Nettoyage des données
   • Gestion des valeurs manquantes
   • Normalisation des données

2. Optimisation des prompts

   • Instructions claires et spécifiques
   • Contexte approprié
   • Format de sortie structuré

3. Gestion des erreurs

   • Validation des entrées
   • Gestion des exceptions
   • Logging approprié

4. Performance

   • Traitement par lots
   • Mise en cache des résultats
   • Limitation des appels API

Ressources supplémentaires

• Documentation OpenAI API
• Pandas Documentation
• Matplotlib Documentation
• Guide d’analyse de données