updated

.env.example

@@ -0,0 +1 @@
+HF_TOKEN=YOURTOKEN

DEPLOY_HF.md

@@ -0,0 +1,201 @@
+# 🚀 Guide de Déploiement sur Hugging Face Spaces
+
+## 📋 Prérequis
+
+1. **Compte Hugging Face** : Créez un compte sur [huggingface.co](https://huggingface.co)
+2. **Token d'accès** : Générez un token sur [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)
+3. **Dataset HackathonCRA/2024** : Assurez-vous d'avoir accès au dataset
+
+## 🔧 Étapes de Déploiement
+
+### 1. Créer un nouveau Space
+
+1. Allez sur [huggingface.co/new-space](https://huggingface.co/new-space)
+2. Remplissez les informations :
+   - **Space name** : `analyse-adventices-cra` (ou votre nom préféré)
+   - **License** : MIT
+   - **SDK** : Gradio
+   - **Hardware** : CPU basic (gratuit)
+
+### 2. Configurer les fichiers
+
+Votre projet contient maintenant tous les fichiers nécessaires :
+
+```
+📁 Votre projet/
+├── 📄 app.py              # Application Gradio modifiée pour HF
+├── 📄 requirements.txt    # Dépendances avec datasets et huggingface_hub
+├── 📄 README.md          # Métadonnées HF (déjà configuré)
+├── 📄 Dockerfile         # Configuration Docker (optionnel)
+└── 📄 sample_data.csv    # Données de fallback
+```
+
+### 3. Uploader les fichiers
+
+**Option A : Interface Web**
+1. Cliquez sur "Files and versions" dans votre Space
+2. Uploadez tous les fichiers un par un
+
+**Option B : Git (Recommandé)**
+```bash
+# Cloner votre space
+git clone https://huggingface.co/spaces/VOTRE_USERNAME/VOTRE_SPACE_NAME
+
+# Copier vos fichiers
+cp app.py requirements.txt README.md sample_data.csv VOTRE_SPACE_NAME/
+
+# Pousser les changements
+cd VOTRE_SPACE_NAME
+git add .
+git commit -m "Ajout de l'application d'analyse des adventices"
+git push
+```
+
+### 4. Configurer les variables d'environnement
+
+1. Dans votre Space, allez dans **Settings**
+2. Ajoutez la variable d'environnement :
+   - **Name** : `HF_TOKEN`
+   - **Value** : Votre token Hugging Face
+   - ✅ Cochez "Secret" pour la sécurité
+
+### 5. Vérifier le dataset
+
+Assurez-vous que :
+- Le dataset `HackathonCRA/2024` existe
+- Vous avez les permissions pour y accéder
+- Le token a les bonnes permissions
+
+## 🏗️ Structure du Code Modifié
+
+### Chargement des données
+```python
+# Configuration HF intégrée
+hf_token = os.environ.get("HF_TOKEN")
+dataset_id = "HackathonCRA/2024"
+
+# Méthode de fallback robuste
+def load_data(self):
+    try:
+        # 1. Essayer depuis Hugging Face
+        dataset = load_dataset(dataset_id, use_auth_token=hf_token)
+        self.df = dataset['train'].to_pandas()
+    except:
+        # 2. Fallback vers fichiers locaux
+        # 3. Génération de données d'exemple si nécessaire
+```
+
+### Configuration Gradio
+```python
+# Optimisé pour HF Spaces
+demo.launch(
+    server_name="0.0.0.0",
+    server_port=7860,
+    share=False
+)
+```
+
+## 🔍 Debugging
+
+### Problèmes courants
+
+1. **Dataset non trouvé**
+   - Vérifiez que `HackathonCRA/2024` existe
+   - Confirmez les permissions d'accès
+   - L'app utilisera des données d'exemple en fallback
+
+2. **Token invalide**
+   - Régénérez votre token HF
+   - Vérifiez qu'il est bien configuré comme secret
+
+3. **Erreurs de dépendances**
+   - Les dépendances sont dans `requirements.txt`
+   - HF Spaces installe automatiquement
+
+### Logs utiles
+```python
+# Ces messages apparaîtront dans les logs HF
+print(f"🤗 Tentative de chargement depuis Hugging Face: {dataset_id}")
+print(f"✅ Données chargées depuis Hugging Face")
+print(f"⚠️ Erreur lors du chargement depuis Hugging Face")
+```
+
+## 🎯 Fonctionnalités
+
+Votre app fonctionnera avec :
+- ✅ **Chargement automatique** depuis le dataset HF
+- ✅ **Fallback robuste** vers données locales/exemple
+- ✅ **Interface Gradio complète** avec tous les onglets
+- ✅ **Visualisations interactives** Plotly
+- ✅ **Analyse des risques** par parcelle
+- ✅ **Recommandations** pour cultures sensibles
+
+## 🚀 Résultat Final
+
+Une fois déployé, votre Space sera accessible à l'adresse :
+`https://huggingface.co/spaces/VOTRE_USERNAME/VOTRE_SPACE_NAME`
+
+L'application se lancera automatiquement et tentera de charger les données depuis `HackathonCRA/2024` !
+
+---
+
+**Bon déploiement ! 🌾✨**
+
+Voici comment lancer votre application en local pour tester avant le déploiement :
+
+## 🔧 Lancement en Local
+
+### 1. **Installation des dépendances**
+```bash
+# Dans votre dossier de projet
+cd /Users/tracyandre/code/hackathon/data
+
+# Installer les dépendances
+pip install -r requirements.txt
+```
+
+### 2. **Configuration des variables d'environnement (optionnel)**
+```bash
+# Créer un fichier .env (optionnel, pour tester avec le vrai dataset HF)
+echo "HF_TOKEN=votre_token_hugging_face" > .env
+
+# Ou exporter directement dans le terminal
+export HF_TOKEN=votre_token_hugging_face
+```
+
+### 3. **Lancer l'application**
+```bash
+<code_block_to_apply_changes_from>
+```
+
+### 4. **Accéder à l'interface**
+Ouvrez votre navigateur et allez à : **http://localhost:7860**
+
+## 🎯 Comportement en Local
+
+Votre app va essayer de charger les données dans cet ordre :
+1. **Dataset HF** `HackathonCRA/2024` (si `HF_TOKEN` configuré)
+2. **Fichiers locaux** (sample_data.csv, etc.)
+3. **Données d'exemple** générées automatiquement
+
+## 🔍 Messages de Debug
+Vous verrez dans la console :
+```
+🤗 Tentative de chargement depuis Hugging Face: HackathonCRA/2024
+✅ Données chargées depuis Hugging Face: HackathonCRA/2024
+# OU
+⚠️ Erreur lors du chargement depuis Hugging Face: [erreur]
+🔄 Basculement vers les fichiers locaux...
+✅ Données chargées depuis: sample_data.csv
+# OU
+⚠️ Aucun fichier de données trouvé, génération de données d'exemple
+```
+
+## 🚀 Test Rapide (sans token HF)
+Si vous voulez juste tester l'interface rapidement :
+```bash
+# L'app fonctionnera avec les données d'exemple générées
+python app.py
+```
+
+L'application sera accessible sur **http://localhost:7860** avec toutes les fonctionnalités ! 🌾✨

app.py

@@ -0,0 +1,442 @@
+import os
+os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
+
+import gradio as gr
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import warnings
+from datasets import load_dataset
+warnings.filterwarnings('ignore')
+
+# Configuration Hugging Face
+hf_token = os.environ.get("HF_TOKEN")
+dataset_id = "HackathonCRA/2024"
+
+# Configuration des graphiques
+plt.style.use('default')
+sns.set_palette("husl")
+
+class AgricultureAnalyzer:
+    def __init__(self):
+        self.df = None
+        self.risk_analysis = None
+        
+    def load_data(self, file_path=None):
+        """Charge les données agricoles depuis Hugging Face ou fichiers locaux"""
+        
+        # D'abord, essayer de charger depuis Hugging Face
+        try:
+            print(f"🤗 Tentative de chargement depuis Hugging Face: {dataset_id}")
+            dataset = load_dataset(dataset_id, use_auth_token=hf_token)
+            
+            # Le dataset peut avoir plusieurs splits, essayer 'train' en premier
+            if 'train' in dataset:
+                # Convertir en DataFrame pandas
+                self.df = dataset['train'].to_pandas()
+                print(f"✅ Données chargées depuis Hugging Face: {dataset_id}")
+                
+                # Si le dataset contient plusieurs fichiers CSV, prendre le premier qui contient les données d'intervention
+                if 'file' in self.df.columns:
+                    # Filtrer pour ne garder que les fichiers d'intervention
+                    intervention_files = self.df[self.df['file'].str.contains('Interventions', na=False)]
+                    if not intervention_files.empty:
+                        self.df = intervention_files
+                
+                return self.analyze_data()
+            else:
+                # Si pas de split 'train', prendre le premier disponible
+                available_splits = list(dataset.keys())
+                if available_splits:
+                    self.df = dataset[available_splits[0]].to_pandas()
+                    print(f"✅ Données chargées depuis Hugging Face (split: {available_splits[0]})")
+                    return self.analyze_data()
+                    
+        except Exception as e:
+            print(f"⚠️ Erreur lors du chargement depuis Hugging Face: {e}")
+            print("🔄 Basculement vers les fichiers locaux...")
+        
+        # Si le chargement HF échoue, utiliser l'ancienne méthode
+        # Liste des chemins possibles pour les données
+        possible_paths = [
+            "data/Interventions-(sortie-excel)-Station_Expérimentale_de_Kerguéhennec-2025.csv",
+            "data/sample_data.csv",
+            "sample_data.csv"
+        ]
+        
+        if file_path:
+            possible_paths.insert(0, file_path)
+        
+        # Essayer de charger depuis les différents chemins
+        for path in possible_paths:
+            try:
+                self.df = pd.read_csv(path, skiprows=1)
+                print(f"✅ Données chargées depuis: {path}")
+                break
+            except FileNotFoundError:
+                continue
+        else:
+            # Si aucun fichier n'est trouvé, créer des données d'exemple
+            print("⚠️ Aucun fichier de données trouvé, génération de données d'exemple")
+            self.df = self.create_sample_data()
+        
+        return self.analyze_data()
+    
+    def create_sample_data(self):
+        """Crée des données d'exemple pour la démo"""
+        np.random.seed(42)
+        n_parcels = 45
+        n_interventions = 653
+        
+        parcels = {
+            'numparcell': np.random.randint(1, n_parcels+1, n_interventions),
+            'nomparc': [f"Parcelle_{i}" for i in np.random.randint(1, n_parcels+1, n_interventions)],
+            'surfparc': np.random.uniform(0.1, 7.0, n_interventions),
+            'libelleusag': np.random.choice(['blé tendre hiver', 'maïs grain', 'colza hiver', 'haricot vert industrie', 
+                                           'CIPAN autre', 'orge hiver', 'soja', 'avoine printemps'], n_interventions),
+            'familleprod': np.random.choice(['Herbicides', 'Fongicides', 'Insecticides', 'Fertilisants'], 
+                                          n_interventions, p=[0.16, 0.25, 0.15, 0.44]),
+            'produit': [f"Produit_{i}" for i in np.random.randint(1, 50, n_interventions)],
+            'quantitetot': np.random.uniform(0.1, 25.0, n_interventions),
+            'libevenem': ['Traitement et protection des cultures'] * n_interventions,
+            'millesime': [2025] * n_interventions,
+            'raisonsoci': ['Station Expérimentale de Kerguéhennec'] * n_interventions
+        }
+        
+        return pd.DataFrame(parcels)
+    
+    def analyze_data(self):
+        """Analyse des données et calcul des risques"""
+        if self.df is None:
+            return "Erreur: Aucune donnée chargée"
+        
+        # Analyse générale
+        general_stats = {
+            'total_parcelles': self.df['numparcell'].nunique(),
+            'total_interventions': len(self.df),
+            'surface_totale': self.df['surfparc'].sum(),
+            'surface_moyenne': self.df['surfparc'].mean(),
+            'periode': f"{self.df['millesime'].min()} - {self.df['millesime'].max()}"
+        }
+        
+        # Analyse des herbicides
+        herbicides_df = self.df[self.df['familleprod'] == 'Herbicides'].copy()
+        herbicide_stats = {
+            'nb_interventions_herbicides': len(herbicides_df),
+            'pourcentage_herbicides': (len(herbicides_df) / len(self.df)) * 100,
+            'parcelles_traitees': herbicides_df['numparcell'].nunique()
+        }
+        
+        # Calcul de l'analyse des risques
+        self.calculate_risk_analysis()
+        
+        return general_stats, herbicide_stats
+    
+    def calculate_risk_analysis(self):
+        """Calcule l'analyse des risques par parcelle"""
+        # Groupement des données par parcelle
+        risk_analysis = self.df.groupby(['numparcell', 'nomparc', 'libelleusag', 'surfparc']).agg({
+            'familleprod': lambda x: (x == 'Herbicides').sum(),  # Nb traitements herbicides
+            'libevenem': lambda x: len(x.unique()),  # Diversité des événements
+            'produit': lambda x: len(x.unique()),  # Diversité des produits
+            'quantitetot': 'sum'  # Quantité totale
+        }).round(2)
+        
+        # Quantités d'herbicides spécifiques
+        herbicide_quantities = self.df[self.df['familleprod'] == 'Herbicides'].groupby(
+            ['numparcell', 'nomparc', 'libelleusag', 'surfparc'])['quantitetot'].sum().fillna(0)
+        
+        risk_analysis['Quantite_herbicides'] = herbicide_quantities.reindex(risk_analysis.index, fill_value=0)
+        
+        risk_analysis.columns = ['Nb_herbicides', 'Diversite_evenements', 'Diversite_produits', 
+                                'Quantite_totale', 'Quantite_herbicides']
+        
+        # Calcul de l'IFT approximatif
+        risk_analysis['IFT_herbicide_approx'] = (risk_analysis['Quantite_herbicides'] / 
+                                                risk_analysis.index.get_level_values('surfparc')).round(2)
+        
+        # Classification du risque
+        def classify_risk(row):
+            ift = row['IFT_herbicide_approx']
+            nb_herb = row['Nb_herbicides']
+            
+            if ift == 0 and nb_herb == 0:
+                return 'TRÈS FAIBLE'
+            elif ift < 1 and nb_herb <= 1:
+                return 'FAIBLE'
+            elif ift < 3 and nb_herb <= 3:
+                return 'MODÉRÉ'
+            elif ift < 5 and nb_herb <= 5:
+                return 'ÉLEVÉ'
+            else:
+                return 'TRÈS ÉLEVÉ'
+        
+        risk_analysis['Risque_adventice'] = risk_analysis.apply(classify_risk, axis=1)
+        
+        # Tri par risque
+        risk_order = ['TRÈS FAIBLE', 'FAIBLE', 'MODÉRÉ', 'ÉLEVÉ', 'TRÈS ÉLEVÉ']
+        risk_analysis['Risk_Score'] = risk_analysis['Risque_adventice'].map({r: i for i, r in enumerate(risk_order)})
+        
+        self.risk_analysis = risk_analysis.sort_values(['Risk_Score', 'IFT_herbicide_approx'])
+    
+    def get_summary_stats(self):
+        """Retourne les statistiques de résumé"""
+        if self.df is None:
+            return "Aucune donnée disponible"
+        
+        stats_text = f"""
+        ## 📊 Statistiques Générales
+        - **Nombre total de parcelles**: {self.df['numparcell'].nunique()}
+        - **Nombre d'interventions**: {len(self.df):,}
+        - **Surface totale**: {self.df['surfparc'].sum():.2f} hectares
+        - **Surface moyenne par parcelle**: {self.df['surfparc'].mean():.2f} hectares
+        - **Période**: {self.df['millesime'].min()} - {self.df['millesime'].max()}
+        
+        ## 🧪 Analyse Herbicides
+        """
+        
+        herbicides_df = self.df[self.df['familleprod'] == 'Herbicides']
+        if len(herbicides_df) > 0:
+            stats_text += f"""
+        - **Interventions herbicides**: {len(herbicides_df)} ({(len(herbicides_df)/len(self.df)*100):.1f}%)
+        - **Parcelles traitées**: {herbicides_df['numparcell'].nunique()}
+        - **Produits herbicides différents**: {herbicides_df['produit'].nunique()}
+        """
+        
+        if self.risk_analysis is not None:
+            risk_distribution = self.risk_analysis['Risque_adventice'].value_counts()
+            stats_text += f"""
+        
+        ## 🎯 Répartition des Risques Adventices
+        """
+            for risk_level in ['TRÈS FAIBLE', 'FAIBLE', 'MODÉRÉ', 'ÉLEVÉ', 'TRÈS ÉLEVÉ']:
+                if risk_level in risk_distribution:
+                    count = risk_distribution[risk_level]
+                    pct = (count / len(self.risk_analysis)) * 100
+                    stats_text += f"- **{risk_level}**: {count} parcelles ({pct:.1f}%)\n"
+        
+        return stats_text
+    
+    def get_low_risk_recommendations(self):
+        """Retourne les recommandations pour les parcelles à faible risque"""
+        if self.risk_analysis is None:
+            return "Analyse des risques non disponible"
+        
+        low_risk = self.risk_analysis[
+            self.risk_analysis['Risque_adventice'].isin(['TRÈS FAIBLE', 'FAIBLE'])
+        ].head(10)
+        
+        recommendations = "## 🌾 TOP 10 - Parcelles Recommandées pour Cultures Sensibles (Pois, Haricot)\n\n"
+        
+        for idx, row in low_risk.iterrows():
+            parcelle, nom, culture, surface = idx
+            recommendations += f"""
+**Parcelle {parcelle}** ({nom})
+- Culture actuelle: {culture}
+- Surface: {surface:.2f} ha
+- Niveau de risque: {row['Risque_adventice']}
+- IFT herbicide: {row['IFT_herbicide_approx']:.2f}
+- Nombre d'herbicides: {row['Nb_herbicides']}
+
+---
+"""
+        
+        return recommendations
+    
+    def create_risk_visualization(self):
+        """Crée la visualisation des risques"""
+        if self.risk_analysis is None:
+            return None
+        
+        risk_df = self.risk_analysis.reset_index()
+        
+        fig = px.scatter(risk_df, 
+                        x='surfparc', 
+                        y='IFT_herbicide_approx',
+                        color='Risque_adventice',
+                        size='Nb_herbicides',
+                        hover_data=['nomparc', 'libelleusag'],
+                        color_discrete_map={
+                            'TRÈS FAIBLE': 'green',
+                            'FAIBLE': 'lightgreen', 
+                            'MODÉRÉ': 'orange',
+                            'ÉLEVÉ': 'red',
+                            'TRÈS ÉLEVÉ': 'darkred'
+                        },
+                        title="🎯 Analyse du Risque Adventice par Parcelle",
+                        labels={
+                            'surfparc': 'Surface de la parcelle (ha)',
+                            'IFT_herbicide_approx': 'IFT Herbicide (approximatif)',
+                            'Risque_adventice': 'Niveau de risque'
+                        })
+        
+        fig.update_layout(width=800, height=600, title_font_size=16)
+        return fig
+    
+    def create_culture_analysis(self):
+        """Analyse par type de culture"""
+        if self.df is None:
+            return None
+        
+        culture_counts = self.df['libelleusag'].value_counts()
+        
+        fig = px.pie(values=culture_counts.values, 
+                    names=culture_counts.index,
+                    title="🌱 Répartition des Cultures")
+        
+        fig.update_layout(width=700, height=500)
+        return fig
+    
+    def create_risk_distribution(self):
+        """Distribution des niveaux de risque"""
+        if self.risk_analysis is None:
+            return None
+        
+        risk_counts = self.risk_analysis['Risque_adventice'].value_counts()
+        
+        fig = px.bar(x=risk_counts.index, 
+                    y=risk_counts.values,
+                    color=risk_counts.index,
+                    color_discrete_map={
+                        'TRÈS FAIBLE': 'green',
+                        'FAIBLE': 'lightgreen', 
+                        'MODÉRÉ': 'orange',
+                        'ÉLEVÉ': 'red',
+                        'TRÈS ÉLEVÉ': 'darkred'
+                    },
+                    title="📊 Distribution des Niveaux de Risque Adventice",
+                    labels={'x': 'Niveau de risque', 'y': 'Nombre de parcelles'})
+        
+        fig.update_layout(width=700, height=500, showlegend=False)
+        return fig
+
+# Initialisation de l'analyseur
+analyzer = AgricultureAnalyzer()
+analyzer.load_data()
+
+# Interface Gradio
+def create_interface():
+    with gr.Blocks(title="🌾 Analyse Adventices Agricoles CRA", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # 🌾 Analyse des Adventices Agricoles - CRA Bretagne
+        
+        **Objectif**: Anticiper et réduire la pression des adventices dans les parcelles agricoles bretonnes
+        
+        Cette application analyse les données historiques pour identifier les parcelles les plus adaptées 
+        à la culture de plantes sensibles comme le pois ou le haricot.
+        """)
+        
+        with gr.Tabs():
+            with gr.TabItem("📊 Vue d'ensemble"):
+                gr.Markdown("## Statistiques générales des données agricoles")
+                
+                stats_output = gr.Markdown(analyzer.get_summary_stats())
+                
+                with gr.Row():
+                    culture_plot = gr.Plot(analyzer.create_culture_analysis())
+                    risk_dist_plot = gr.Plot(analyzer.create_risk_distribution())
+            
+            with gr.TabItem("🎯 Analyse des Risques"):
+                gr.Markdown("## Cartographie des risques adventices par parcelle")
+                
+                risk_plot = gr.Plot(analyzer.create_risk_visualization())
+                
+                gr.Markdown("""
+                **Interprétation du graphique**:
+                - **Axe X**: Surface de la parcelle (hectares)
+                - **Axe Y**: IFT Herbicide approximatif 
+                - **Couleur**: Niveau de risque adventice
+                - **Taille**: Nombre d'herbicides utilisés
+                
+                Les parcelles vertes (risque faible) sont idéales pour les cultures sensibles.
+                """)
+            
+            with gr.TabItem("🌾 Recommandations"):
+                gr.Markdown(analyzer.get_low_risk_recommendations())
+                
+                gr.Markdown("""
+                ## 💡 Conseils pour la gestion des adventices
+                
+                ### Parcelles à Très Faible Risque (Vertes)
+                - ✅ **Idéales pour pois et haricot**
+                - ✅ Historique d'usage herbicide minimal
+                - ✅ Pression adventice faible attendue
+                
+                ### Parcelles à Faible Risque (Vert clair)
+                - ⚠️ Surveillance légère recommandée
+                - ✅ Conviennent aux cultures sensibles avec précautions
+                
+                ### Parcelles à Risque Modéré/Élevé (Orange/Rouge)
+                - ❌ Éviter pour cultures sensibles
+                - 🔍 Rotation nécessaire avant implantation
+                - 📈 Surveillance renforcée des adventices
+                
+                ### Stratégies alternatives
+                - **Rotation longue**: 3-4 ans avant cultures sensibles
+                - **Cultures intermédiaires**: CIPAN pour réduire la pression
+                - **Techniques mécaniques**: Hersage, binage
+                - **Biostimulants**: Renforcement naturel des cultures
+                """)
+            
+            with gr.TabItem("ℹ️ À propos"):
+                gr.Markdown("""
+                ## 🎯 Méthodologie
+                
+                Cette analyse se base sur :
+                
+                ### Calcul de l'IFT (Indice de Fréquence de Traitement)
+                - **IFT ≈ Quantité appliquée / Surface de parcelle**
+                - Indicateur de l'intensité des traitements herbicides
+                
+                ### Classification des risques
+                - **TRÈS FAIBLE**: IFT = 0, aucun herbicide
+                - **FAIBLE**: IFT < 1, usage minimal
+                - **MODÉRÉ**: IFT < 3, usage modéré  
+                - **ÉLEVÉ**: IFT < 5, usage important
+                - **TRÈS ÉLEVÉ**: IFT ≥ 5, usage intensif
+                
+                ### Données analysées
+                - **Source**: Station Expérimentale de Kerguéhennec
+                - **Période**: Campagne 2025
+                - **Variables**: Interventions, produits, quantités, surfaces
+                
+                ---
+                
+                **Développé pour le Hackathon CRA Bretagne** 🏆
+                
+                *Application d'aide à la décision pour une agriculture durable*
+                """)
+        
+        # Bouton de rafraîchissement
+        refresh_btn = gr.Button("🔄 Actualiser les données", variant="secondary")
+        
+        def refresh_data():
+            analyzer.load_data()
+            return (
+                analyzer.get_summary_stats(),
+                analyzer.create_culture_analysis(),
+                analyzer.create_risk_distribution(),
+                analyzer.create_risk_visualization(),
+                analyzer.get_low_risk_recommendations()
+            )
+        
+        refresh_btn.click(
+            refresh_data,
+            outputs=[stats_output, culture_plot, risk_dist_plot, risk_plot]
+        )
+    
+    return demo
+
+# Lancement de l'application
+if __name__ == "__main__":
+    demo = create_interface()
+    # Configuration pour Hugging Face Spaces
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False  # Pas besoin de share sur HF Spaces
+    )

requirements.txt

@@ -0,0 +1,10 @@
+gradio==4.31.0
+pandas>=2.0.0
+numpy>=1.21.0,<3.0.0
+matplotlib>=3.5.0
+seaborn>=0.11.0
+plotly>=5.0.0
+scipy>=1.7.0
+scikit-learn>=1.0.0
+datasets>=2.0.0
+huggingface_hub>=0.16.0

sample_data.csv

@@ -0,0 +1,22 @@
+Station Expérimentale de Kerguéhennec - Données d'intervention 2025
+millesime,raisonsoci,siret,pacage,refca,numilot,numparcell,nomparc,surfparc,rang,estpac,libelleusag,datedebut,datefin,libperiode,libregroupe,libevenem,dureeeffect,familleprod,produit,quantitetot,unite,neffqte,peffqte,kqte,teneurn,teneurp,teneurk,keq,volumebo,codeamm,codegnis,materiel,mainoeuvre
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,1102,Bourg bas,6.73,1,True,blé tendre hiver,15/03/25,15/03/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,LUMEO,0.20,L,,,,,,,,,,,Pulvérisateur,2.5
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,1301,Bois Guillemin,5.97,1,True,blé tendre hiver,20/03/25,20/03/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,PEAK,0.01,L,,,,,,,,,,,Pulvérisateur,2.0
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,1101,Bourg Haut,5.55,1,True,maïs grain,25/04/25,25/04/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,GLISTER ULTRA 360,3.50,L,,,,,,,,,,,Pulvérisateur,3.0
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,1001,Carancier Ht,5.46,1,True,colza hiver,10/04/25,10/04/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,BISCOTO,1.20,L,,,,,,,,,,,Pulvérisateur,2.5
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,48,Etang Bois,3.36,1,True,haricot vert industrie,05/05/25,05/05/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,ISARD,2.40,L,,,,,,,,,,,Pulvérisateur,4.0
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,44,La Défriche,3.25,1,True,CIPAN autre,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,2,Kersuzan Bas,3.05,1,True,CIPAN autre,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,81,Charbonnerie Entrée,3.01,1,True,CIPAN autre,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,11,Cléhury,2.97,1,True,orge hiver,12/04/25,12/04/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,FREEWAY 480,0.80,L,,,,,,,,,,,Pulvérisateur,2.0
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,5,Etang Moulin,2.85,1,True,CIPAN autre,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,50,Lann Chebot Le Roch,2.20,1,True,blé tendre hiver,18/03/25,18/03/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,NISSHIN PREMIUM 6 OD,1.50,L,,,,,,,,,,,Pulvérisateur,3.5
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,16,Champ ferme W du sol parking,1.95,1,True,maïs grain,28/04/25,28/04/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,ALABAMA,1.20,L,,,,,,,,,,,Pulvérisateur,2.5
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,39,Champ ferme transfert,1.85,1,True,blé tendre hiver,22/03/25,22/03/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,CENT-7,0.15,L,,,,,,,,,,,Pulvérisateur,2.0
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,1201,Champ Robert,1.75,1,True,blé tendre hiver,25/03/25,25/03/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,CORUM,0.95,L,,,,,,,,,,,Pulvérisateur,2.5
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,38,Champ ferme W du sol,1.65,1,True,colza hiver,15/04/25,15/04/25,,Herbicides,Traitement et protection des cultures,1,Herbicides,LUMEO,0.18,L,,,,,,,,,,,Pulvérisateur,2.0
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,14,Grand-Champ 1 essai soja 25,0.53,1,True,soja,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,10,Penderff 7 analytique,1.56,1,True,avoine printemps,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,33,Penderff Luzerne,2.10,1,True,luzerne,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,4,Penderff 1,0.37,1,True,feverole printemps,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0
+2025,Station Expérimentale de Kerguéhennec,12345678901234,1001,CA001,1,6,Lann Chebot chemin,0.11,1,True,CIPAN autre,,,,,Traitement et protection des cultures,0,,,0.00,L,,,,,,,,,,,Pulvérisateur,0.0