Update app.py

app.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-Barouia-Cortex 3.0 - Système Avancé d'Optimisation Cognitive
-Compression Token, Mémoire Optimisée, Entraînement Accéléré
+Barouia-Cortex 3.0 - Version corrigée
+Système Avancé d'Optimisation Cognitive
 """
 
 from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect
@@ -29,48 +29,37 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(level
 logger = logging.getLogger("barouia_cortex_3")
 
 # =============================================================================
-# NOUVEAU SYSTÈME DE COMPRESSION DE TOKENS
+# SYSTÈME DE COMPRESSION DE TOKENS
 # =============================================================================
 
 class TokenCompressor:
-    """Système avancé de compression lexicale - Faire plus avec moins de tokens"""
+    """Système avancé de compression lexicale"""
     
     def __init__(self):
         self.dictionnaire_compresse = {}
         self.dictionnaire_decompresse = {}
         self.mots_frequents = self.charger_mots_frequents()
-        self.compression_level = 12  # Niveau de compression maximal
+        self.compression_level = 12
         logger.info("🔤 Compresseur Token initialisé")
     
     def charger_mots_frequents(self) -> Dict[str, int]:
-        """Charge les mots fréquents du français pour l'optimisation"""
+        """Charge les mots fréquents du français"""
         mots_base = {
             'le', 'la', 'les', 'de', 'du', 'des', 'un', 'une', 'et', 'ou',
-            'que', 'qui', 'dans', 'en', 'sur', 'avec', 'pour', 'par', 'est',
-            'son', 'sa', 'ses', 'ces', 'cet', 'cette', 'mon', 'ton', 'notre',
-            'votre', 'leur', 'je', 'tu', 'il', 'elle', 'nous', 'vous', 'ils',
-            'elles', 'ai', 'as', 'a', 'avons', 'avez', 'ont', 'serai', 'seras',
-            'sera', 'serons', 'serez', 'seront', 'étais', 'était', 'étions',
-            'étiez', 'étaient', 'sois', 'soit', 'soyons', 'soyez', 'soient'
+            'que', 'qui', 'dans', 'en', 'sur', 'avec', 'pour', 'par', 'est'
         }
         return {mot: idx for idx, mot in enumerate(mots_base)}
     
     def compresser_texte(self, texte: str) -> Tuple[str, float]:
-        """Compresse un texte avec optimisation token avancée"""
+        """Compresse un texte avec optimisation token"""
         try:
-            # Niveau 1: Remplacement des mots fréquents
-            texte_opti = self.remplacer_mots_frequents(texte)
-            
-            # Niveau 2: Compression zlib avancée
-            texte_bytes = texte_opti.encode('utf-8')
+            # Compression zlib avancée
+            texte_bytes = texte.encode('utf-8')
             texte_compresse = zlib.compress(texte_bytes, level=self.compression_level)
-            
-            # Niveau 3: Encodage base64 pour sécurité
             texte_final = base64.b85encode(texte_compresse).decode('ascii')
             
             # Calcul taux de compression
             taux_compression = (1 - len(texte_final) / len(texte)) * 100
-            
             return texte_final, max(0, taux_compression)
             
         except Exception as e:
@@ -80,80 +69,35 @@ class TokenCompressor:
     def decompresser_texte(self, texte_compresse: str) -> str:
         """Décompresse un texte optimisé"""
         try:
-            # Décodage base64
             texte_bytes = base64.b85decode(texte_compresse.encode('ascii'))
-            
-            # Décompression zlib
             texte_decompresse = zlib.decompress(texte_bytes)
-            
-            # Restauration des mots fréquents
-            texte_final = self.restaurer_mots_frequents(texte_decompresse.decode('utf-8'))
-            
-            return texte_final
-            
+            return texte_decompresse.decode('utf-8')
         except Exception as e:
             logger.error(f"❌ Erreur décompression: {e}")
             return texte_compresse
-    
-    def remplacer_mots_frequents(self, texte: str) -> str:
-        """Remplace les mots fréquents par des tokens courts"""
-        mots = texte.split()
-        mots_opti = []
-        
-        for mot in mots:
-            mot_clean = mot.lower().strip('.,!?;:')
-            if mot_clean in self.mots_frequents:
-                # Remplacer par token court
-                token = f"ƒ{self.mots_frequents[mot_clean]:02d}"
-                mots_opti.append(token)
-            else:
-                mots_opti.append(mot)
-        
-        return ' '.join(mots_opti)
-    
-    def restaurer_mots_frequents(self, texte_opti: str) -> str:
-        """Restaure les mots fréquents depuis les tokens"""
-        def remplacer_token(match):
-            token = match.group(0)
-            idx = int(token[1:])  # Extraire l'index
-            # Trouver le mot original
-            for mot, index in self.mots_frequents.items():
-                if index == idx:
-                    return mot
-            return token
-        
-        # Remplacer les tokens ƒXX par les mots originaux
-        texte_restaure = re.sub(r'ƒ\d{2,3}', remplacer_token, texte_opti)
-        return texte_restaure
 
 # =============================================================================
-# SYSTÈME DE MÉMOIRE OPTIMISÉE AVEC COMPRESSION
+# SYSTÈME DE MÉMOIRE OPTIMISÉE
 # =============================================================================
 
 class MemoireCompressee:
-    """Système de mémoire avec compression et cache intelligent"""
+    """Système de mémoire avec compression"""
     
-    def __init__(self, capacite_max: int = 1000000):
+    def __init__(self, capacite_max: int = 100000):
         self.capacite_max = capacite_max
         self.memoire_principale = {}
-        self.cache_actif = deque(maxlen=1000)  # Cache LRU
-        self.historique_acces = defaultdict(int)
+        self.cache_actif = deque(maxlen=1000)
         self.compresseur = TokenCompressor()
-        self.taux_compression_moyen = 0.0
         logger.info("💾 Mémoire compressée initialisée")
     
     def stocker(self, cle: str, valeur: Any) -> bool:
-        """Stocke une valeur avec compression automatique"""
+        """Stocke une valeur avec compression"""
         try:
             if len(self.memoire_principale) >= self.capacite_max:
                 self.liberer_espace()
             
-            # Compression de la valeur si c'est du texte
             if isinstance(valeur, str):
-                valeur_compressee, taux_compression = self.compresseur.compresser_texte(valeur)
-                self.taux_compression_moyen = (
-                    self.taux_compression_moyen * 0.9 + taux_compression * 0.1
-                )
+                valeur_compressee, _ = self.compresseur.compresser_texte(valeur)
             else:
                 valeur_compressee = valeur
             
@@ -164,9 +108,7 @@ class MemoireCompressee:
                 'acces': 0
             }
             
-            # Mettre à jour le cache
             self.mettre_a_jour_cache(cle)
-            
             return True
             
         except Exception as e:
@@ -174,24 +116,19 @@ class MemoireCompressee:
             return False
     
     def recuperer(self, cle: str) -> Optional[Any]:
-        """Récupère une valeur avec décompression automatique"""
+        """Récupère une valeur avec décompression"""
         try:
             if cle not in self.memoire_principale:
                 return None
             
             donnees = self.memoire_principale[cle]
             donnees['acces'] += 1
-            self.historique_acces[cle] += 1
             
             valeur = donnees['valeur']
-            
-            # Décompression si nécessaire
             if donnees['type'] == 'texte':
                 valeur = self.compresseur.decompresser_texte(valeur)
             
-            # Mettre à jour le cache
             self.mettre_a_jour_cache(cle)
-            
             return valeur
             
         except Exception as e:
@@ -199,23 +136,19 @@ class MemoireCompressee:
             return None
     
     def liberer_espace(self):
-        """Libère de l'espace en supprimant les éléments les moins utilisés"""
+        """Libère de l'espace"""
         if not self.memoire_principale:
             return
         
-        # Trouver les éléments les moins utilisés
         elements_tries = sorted(
             self.memoire_principale.items(),
             key=lambda x: (x[1]['acces'], x[1]['timestamp'])
         )
         
-        # Supprimer les 10% les moins utilisés
         a_supprimer = max(1, len(elements_tries) // 10)
         for i in range(a_supprimer):
             cle = elements_tries[i][0]
             del self.memoire_principale[cle]
-            if cle in self.historique_acces:
-                del self.historique_acces[cle]
     
     def mettre_a_jour_cache(self, cle: str):
         """Met à jour le cache LRU"""
@@ -228,8 +161,6 @@ class MemoireCompressee:
         return {
             "utilisation": len(self.memoire_principale),
             "capacite_max": self.capacite_max,
-            "taux_compression_moyen": self.taux_compression_moyen,
-            "acces_total": sum(self.historique_acces.values()),
             "elements_caches": len(self.cache_actif)
         }
 
@@ -238,52 +169,33 @@ class MemoireCompressee:
 # =============================================================================
 
 class MoteurEntrainement:
-    """Système d'entraînement neuronal accéléré avec optimisation mémoire"""
+    """Système d'entraînement neuronal accéléré"""
     
     def __init__(self):
         self.cycles_entrainement = 0
         self.vitesse_entrainement = 1.0
-        self.dernier_entrainement = time.time()
-        self.memoire_entrainement = MemoireCompressee(500000)
-        self.modeles_actifs = {}
         self.performance_history = deque(maxlen=100)
         logger.info("⚡ Moteur d'entraînement initialisé")
     
     async def entrainer_modele(self, donnees: List[Any], epochs: int = 10) -> Dict[str, Any]:
-        """Entraîne un modèle avec optimisation accélérée"""
+        """Entraîne un modèle avec optimisation"""
         debut = time.time()
         
         try:
-            # Simulation d'entraînement optimisé
             for epoch in range(epochs):
-                # Compression des données d'entraînement
-                donnees_compressees = []
-                for donnee in donnees:
-                    if isinstance(donnee, str):
-                        compresse, _ = TokenCompressor().compresser_texte(donnee)
-                        donnees_compressees.append(compresse)
-                    else:
-                        donnees_compressees.append(donnee)
-                
-                # Entraînement sur données compressées (simulation)
-                await asyncio.sleep(0.01)  # Simulation traitement
-                
-                # Mise à jour des métriques
+                await asyncio.sleep(0.01)
                 performance = self.calculer_performance(epoch, epochs)
                 self.performance_history.append(performance)
             
             duree = time.time() - debut
             self.cycles_entrainement += 1
-            
-            # Ajustement automatique de la vitesse
             self.ajuster_vitesse(duree)
             
             return {
                 "success": True,
                 "cycles_completes": epochs,
                 "duree_totale": duree,
-                "vitesse_finale": self.vitesse_entrainement,
-                "performance_moyenne": np.mean([p['accuracy'] for p in self.performance_history]) if self.performance_history else 0.0
+                "vitesse_finale": self.vitesse_entrainement
             }
             
         except Exception as e:
@@ -293,26 +205,22 @@ class MoteurEntrainement:
     def calculer_performance(self, epoch: int, total_epochs: int) -> Dict[str, float]:
         """Calcule les métriques de performance"""
         progression = epoch / total_epochs
-        accuracy = 0.5 + 0.5 * progression  # Simulation amélioration
-        loss = 1.0 - progression
+        accuracy = 0.5 + 0.5 * progression
         
         return {
             "epoch": epoch,
             "accuracy": accuracy,
-            "loss": loss,
+            "loss": 1.0 - progression,
             "timestamp": time.time()
         }
     
     def ajuster_vitesse(self, duree_entrainement: float):
         """Ajuste automatiquement la vitesse d'entraînement"""
         if duree_entrainement < 1.0:
-            # Accélérer si trop rapide
             self.vitesse_entrainement *= 1.1
         elif duree_entrainement > 5.0:
-            # Ralentir si trop lent
             self.vitesse_entrainement *= 0.9
         
-        # Limites de sécurité
         self.vitesse_entrainement = max(0.1, min(5.0, self.vitesse_entrainement))
     
     def get_statistiques(self) -> Dict[str, Any]:
@@ -320,91 +228,41 @@ class MoteurEntrainement:
         return {
             "cycles_entrainement": self.cycles_entrainement,
             "vitesse_actuelle": self.vitesse_entrainement,
-            "performance_history": list(self.performance_history),
-            "memoire_entrainement": self.memoire_entrainement.get_statistiques()
+            "performance_history": list(self.performance_history)
         }
 
 # =============================================================================
-# FENÊTRE DE CONTEXTE ÉTENDUE INTELLIGENTE
+# FENÊTRE DE CONTEXTE ÉTENDUE
 # =============================================================================
 
 class FenetreContexteEtendue:
-    """Système de fenêtre de contexte étendue avec gestion intelligente"""
+    """Système de fenêtre de contexte étendue"""
     
-    def __init__(self, taille_max: int = 10000, compression_auto: bool = True):
+    def __init__(self, taille_max: int = 10000):
         self.taille_max = taille_max
-        self.compression_auto = compression_auto
         self.contenu = deque(maxlen=taille_max)
-        self.contenu_compresse = deque(maxlen=taille_max)
         self.compresseur = TokenCompressor()
-        self.importance_scores = {}
         logger.info("🪟 Fenêtre de contexte étendue initialisée")
     
     def ajouter_contexte(self, texte: str, importance: float = 1.0):
         """Ajoute du contexte avec gestion d'importance"""
-        if self.compression_auto:
-            texte_compresse, taux_compression = self.compresseur.compresser_texte(texte)
-            self.contenu_compresse.append(texte_compresse)
-        else:
-            self.contenu.append(texte)
-        
-        # Stocker le score d'importance
-        cle = hash(texte)
-        self.importance_scores[cle] = importance
-        
-        # Nettoyer si nécessaire
-        if len(self.contenu) + len(self.contenu_compresse) > self.taille_max:
-            self.nettoyer_contexte()
+        texte_compresse, _ = self.compresseur.compresser_texte(texte)
+        self.contenu.append(texte_compresse)
     
     def obtenir_contexte(self, limite_tokens: int = 2000) -> str:
         """Récupère le contexte le plus pertinent"""
         contexte_pertinent = []
-        tokens_utilises = 0
-        
-        # Combiner contenu normal et compressé
-        tous_elements = list(self.contenu) + list(self.contenu_compresse)
-        
-        for element in tous_elements:
-            if self.compression_auto and element in self.contenu_compresse:
-                # Décompresser si nécessaire
-                element_decompresse = self.compresseur.decompresser_texte(element)
-                taille_element = len(element_decompresse.split())
-            else:
-                taille_element = len(element.split())
-            
-            if tokens_utilises + taille_element <= limite_tokens:
-                contexte_pertinent.append(element)
-                tokens_utilises += taille_element
-            else:
-                break
+        for element in list(self.contenu)[-10:]:  # 10 derniers éléments
+            element_decompresse = self.compresseur.decompresser_texte(element)
+            contexte_pertinent.append(element_decompresse)
         
         return " ".join(contexte_pertinent)
     
-    def nettoyer_contexte(self):
-        """Nettoie le contexte en gardant les éléments les plus importants"""
-        # Trier par importance
-        elements_importants = sorted(
-            self.importance_scores.items(),
-            key=lambda x: x[1],
-            reverse=True
-        )
-        
-        # Garder seulement les 80% plus importants
-        a_garder = len(elements_importants) * 8 // 10
-        elements_a_supprimer = elements_importants[a_garder:]
-        
-        for cle, _ in elements_a_supprimer:
-            if cle in self.importance_scores:
-                del self.importance_scores[cle]
-    
     def get_statistiques(self) -> Dict[str, Any]:
         """Retourne les statistiques de la fenêtre de contexte"""
         return {
-            "taille_actuelle": len(self.contenu) + len(self.contenu_compresse),
-            "taille_max": self.taille_max,
-            "elements_compresses": len(self.contenu_compresse),
-            "elements_normaux": len(self.contenu),
-            "scores_importance": len(self.importance_scores)
+            "taille_actuelle": len(self.contenu),
+            "taille_max": self.taille_max
         }
 
 # =============================================================================
@@ -415,35 +273,21 @@ class CortexOptimise:
     """Cortex 3.0 avec toutes les optimisations intégrées"""
     
     def __init__(self):
-        # Systèmes d'optimisation
         self.compresseur = TokenCompressor()
         self.memoire = MemoireCompressee()
         self.moteur_entrainement = MoteurEntrainement()
         self.fenetre_contexte = FenetreContexteEtendue()
         
-        # État du cortex
         self.etat = {
             "performance_globale": {
                 "temps_reponse": 0.05,
                 "precision": 95.0,
                 "efficacite_memoire": 85.0,
                 "vitesse_traitement": 1.0
-            },
-            "optimisations_actives": {
-                "compression_tokens": True,
-                "memoire_compressee": True,
-                "entrainement_accelere": True,
-                "contexte_etendu": True
-            },
-            "statistiques_avancees": {
-                "tokens_compresses": 0,
-                "economie_memoire": 0.0,
-                "cycles_optimisation": 0,
-                "erreurs_evitees": 0
             }
         }
         
-        self.historique_performances = deque(maxlen=500)
+        self.historique_performances = deque(maxlen=100)
         logger.info("🧠 Cortex Optimisé 3.0 initialisé")
     
     async def traiter_requete_optimisee(self, requete: str) -> Dict[str, Any]:
@@ -451,20 +295,12 @@ class CortexOptimise:
         debut = time.time()
         
         try:
-            # 1. Compression de la requête
             requete_compressee, taux_compression = self.compresseur.compresser_texte(requete)
-            
-            # 2. Ajout au contexte
-            self.fenetre_contexte.ajouter_contexte(requete, importance=0.8)
-            
-            # 3. Traitement avec mémoire optimisée
+            self.fenetre_contexte.ajouter_contexte(requete)
             contexte = self.fenetre_contexte.obtenir_contexte()
             reponse = await self.generer_reponse_optimisee(requete, contexte)
-            
-            # 4. Compression de la réponse
             reponse_compressee, _ = self.compresseur.compresser_texte(reponse)
             
-            # 5. Mise à jour des statistiques
             duree = time.time() - debut
             self.mettre_a_jour_statistiques(duree, taux_compression)
             
@@ -473,8 +309,7 @@ class CortexOptimise:
                 "reponse_originale": reponse,
                 "reponse_compressee": reponse_compressee,
                 "taux_compression": taux_compression,
-                "temps_traitement": duree,
-                "contexte_utilise": len(contexte) > 0
+                "temps_traitement": duree
             }
             
         except Exception as e:
@@ -483,30 +318,27 @@ class CortexOptimise:
     
     async def generer_reponse_optimisee(self, requete: str, contexte: str) -> str:
         """Génère une réponse optimisée"""
-        # Simulation d'un modèle IA optimisé
-        await asyncio.sleep(0.02)  # Temps de traitement réduit
+        await asyncio.sleep(0.02)
         
         reponses_avancees = [
-            f"🧠 [Système Optimisé] J'ai analysé votre requête avec compression token avancée. ",
-            f"⚡ [Traitement Accéléré] Votre demande a été processée en mode haute performance. ",
-            f"💾 [Mémoire Optimisée] J'utilise actuellement {self.memoire.get_statistiques()['taux_compression_moyen']:.1f}% de compression. ",
-            f"🪟 [Contexte Étendu] J'ai accès à {self.fenetre_contexte.get_statistiques()['taille_actuelle']} éléments contextuels. ",
-            f"🎯 [Précision Améliorée] Mes algorithmes sont optimisés pour une meilleure compréhension. "
+            f"🧠 [Système Optimisé] J'ai analysé votre requête avec compression token avancée.",
+            f"⚡ [Traitement Accéléré] Votre demande a été processée en mode haute performance.",
+            f"💾 [Mémoire Optimisée] Système de compression activé avec succès.",
         ]
         
         reponse_base = np.random.choice(reponses_avancees)
         
         if "état" in requete.lower() and "cortex" in requete.lower():
             stats = self.get_statistiques_completes()
-            return f"{reponse_base} Voici mon état actuel: {json.dumps(stats, indent=2)}"
+            return f"{reponse_base} État du système: Performance {stats['etat_cortex']['performance_globale']['precision']}%"
         elif "performance" in requete.lower():
             perf = self.moteur_entrainement.get_statistiques()
-            return f"{reponse_base} Performances d'entraînement: {perf['vitesse_actuelle']:.2f}x vitesse normale."
+            return f"{reponse_base} Vitesse d'entraînement: {perf['vitesse_actuelle']:.2f}x"
         elif "mémoire" in requete.lower():
             mem = self.memoire.get_statistiques()
-            return f"{reponse_base} Mémoire: {mem['utilisation']}/{mem['capacite_max']} éléments, compression: {mem['taux_compression_moyen']:.1f}%"
+            return f"{reponse_base} Mémoire: {mem['utilisation']}/{mem['capacite_max']} éléments"
         else:
-            return f"{reponse_base} J'ai bien compris: '{requete}'. Comment puis-je vous aider davantage ?"
+            return f"{reponse_base} J'ai bien compris: '{requete}'. Comment puis-je vous aider ?"
     
     def mettre_a_jour_statistiques(self, duree: float, taux_compression: float):
         """Met à jour les statistiques avancées"""
@@ -514,18 +346,10 @@ class CortexOptimise:
             self.etat["performance_globale"]["temps_reponse"] * 0.9 + duree * 0.1
         )
         
-        self.etat["statistiques_avancees"]["tokens_compresses"] += 1
-        self.etat["statistiques_avancees"]["economie_memoire"] = (
-            self.etat["statistiques_avancees"]["economie_memoire"] * 0.95 + taux_compression * 0.05
-        )
-        self.etat["statistiques_avancees"]["cycles_optimisation"] += 1
-        
-        # Historique des performances
         self.historique_performances.append({
             "timestamp": time.time(),
             "temps_reponse": duree,
-            "taux_compression": taux_compression,
-            "performance": self.etat["performance_globale"]["precision"]
+            "taux_compression": taux_compression
         })
     
     def get_statistiques_completes(self) -> Dict[str, Any]:
@@ -535,17 +359,16 @@ class CortexOptimise:
             "performance_entrainement": self.moteur_entrainement.get_statistiques(),
             "statistiques_memoire": self.memoire.get_statistiques(),
             "fenetre_contexte": self.fenetre_contexte.get_statistiques(),
-            "historique_performances": list(self.historique_performances)[-10:],  # 10 derniers
             "timestamp": datetime.now().isoformat()
         }
 
 # =============================================================================
-# APPLICATION FASTAPI AVEC TOUTES LES OPTIMISATIONS
+# APPLICATION FASTAPI
 # =============================================================================
 
 app = FastAPI(
     title="Barouia-Cortex 3.0",
-    description="Système IA avancé avec compression token et optimisation mémoire",
+    description="Système IA avancé avec optimisation",
     version="3.0.0"
 )
 
@@ -563,36 +386,23 @@ cortex_optimise = CortexOptimise()
 class ChatRequest(BaseModel):
     message: str
     conversation_id: Optional[str] = None
-    optimisations: Optional[bool] = True
 
 class EntrainementRequest(BaseModel):
     donnees: List[str]
-    epochs: int = 10
+    epochs: int = 5
 
-# Routes API optimisées
+# Routes API
 @app.get("/")
 async def root():
     return {
         "message": "Barouia-Cortex 3.0 - Système Optimisé", 
         "status": "active", 
-        "version": "3.0.0",
-        "optimisations": [
-            "Compression Token Avancée",
-            "Mémoire Optimisée", 
-            "Entraînement Accéléré",
-            "Fenêtre Contexte Étendue"
-        ]
+        "version": "3.0.0"
     }
 
 @app.get("/health")
 async def health_check():
-    stats = cortex_optimise.get_statistiques_completes()
-    return {
-        "status": "ok", 
-        "timestamp": time.time(),
-        "performance": stats["etat_cortex"]["performance_globale"],
-        "optimisations_actives": stats["etat_cortex"]["optimisations_actives"]
-    }
+    return {"status": "ok", "timestamp": time.time()}
 
 @app.get("/api/statistiques/avancees")
 async def get_statistiques_avancees():
@@ -600,23 +410,16 @@ async def get_statistiques_avancees():
 
 @app.post("/api/chat/optimise")
 async def chat_optimise(request: ChatRequest):
-    """Endpoint de chat avec toutes les optimisations"""
+    """Endpoint de chat avec optimisations"""
     try:
-        if request.optimisations:
-            resultat = await cortex_optimise.traiter_requete_optimisee(request.message)
-        else:
-            # Mode sans optimisation (pour comparaison)
-            resultat = {"success": True, "reponse_originale": f"Réponse standard: {request.message}"}
-        
+        resultat = await cortex_optimise.traiter_requete_optimisee(request.message)
         return {
             "success": True,
             "reponse": resultat.get("reponse_originale", "Erreur"),
             "statistiques": resultat,
             "cortex_state": cortex_optimise.get_statistiques_completes()
         }
-        
     except Exception as e:
-        logger.error(f"❌ Erreur chat optimisé: {e}")
         return {"success": False, "error": str(e)}
 
 @app.post("/api/entrainement/demarrer")
@@ -626,19 +429,16 @@ async def demarrer_entrainement(request: EntrainementRequest):
         resultat = await cortex_optimise.moteur_entrainement.entrainer_modele(
             request.donnees, request.epochs
         )
-        
         return {
             "success": resultat["success"],
-            "resultat_entrainement": resultat,
-            "statistiques_cortex": cortex_optimise.get_statistiques_completes()
+            "resultat_entrainement": resultat
         }
-        
     except Exception as e:
         return {"success": False, "error": str(e)}
 
 @app.websocket("/ws/optimise")
 async def websocket_optimise(websocket: WebSocket):
-    """WebSocket pour communications optimisées en temps réel"""
+    """WebSocket pour communications optimisées"""
     await websocket.accept()
     try:
         while True:
@@ -652,14 +452,12 @@ async def websocket_optimise(websocket: WebSocket):
             await websocket.send_json({
                 "type": "reponse_optimisee",
                 "reponse": resultat.get("reponse_originale", ""),
-                "statistiques": resultat,
-                "cortex_state": cortex_optimise.get_statistiques_completes()
+                "statistiques": resultat
             })
-            
     except WebSocketDisconnect:
         logger.info("WebSocket optimisé déconnecté")
 
-# Interface dashboard optimisée
+# Interface dashboard simplifiée
 @app.get("/dashboard", response_class=HTMLResponse)
 async def dashboard_optimise():
     html_content = """
@@ -668,19 +466,19 @@ async def dashboard_optimise():
     <head>
         <meta charset="UTF-8">
         <meta name="viewport" content="width=device-width, initial-scale=1.0">
-        <title>Barouia-Cortex 3.0 - Système Optimisé</title>
+        <title>Barouia-Cortex 3.0</title>
         <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
         <style>
             * { margin: 0; padding: 0; box-sizing: border-box; }
             body {
-                font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+                font-family: Arial, sans-serif;
                 background: linear-gradient(135deg, #0f0f23 0%, #1a1a2e 100%);
                 color: white;
                 min-height: 100vh;
                 padding: 20px;
             }
             .container {
-                max-width: 1400px;
+                max-width: 1200px;
                 margin: 0 auto;
             }
             .header {
@@ -690,28 +488,14 @@ async def dashboard_optimise():
                 border-radius: 15px;
                 margin-bottom: 2rem;
             }
-            .header h1 {
-                font-size: 2.5rem;
-                margin-bottom: 0.5rem;
-            }
-            .header .version {
-                background: rgba(255,255,255,0.2);
-                padding: 0.3rem 1rem;
-                border-radius: 20px;
-                display: inline-block;
-                margin-top: 0.5rem;
-            }
-            .dashboard-grid {
+            .dashboard {
                 display: grid;
-                grid-template-columns: 1fr 1fr 1fr;
-                gap: 1.5rem;
+                grid-template-columns: 1fr 1fr;
+                gap: 2rem;
                 margin-bottom: 2rem;
             }
-            @media (max-width: 1200px) {
-                .dashboard-grid { grid-template-columns: 1fr 1fr; }
-            }
             @media (max-width: 768px) {
-                .dashboard-grid { grid-template-columns: 1fr; }
+                .dashboard { grid-template-columns: 1fr; }
             }
             .card {
                 background: rgba(255, 255, 255, 0.1);
@@ -719,17 +503,11 @@ async def dashboard_optimise():
                 border-radius: 15px;
                 border: 1px solid rgba(102, 126, 234, 0.3);
             }
-            .card h3 {
-                margin-bottom: 1rem;
-                color: #667eea;
-                display: flex;
-                align-items: center;
-                gap: 0.5rem;
-            }
             .metrics-grid {
                 display: grid;
                 grid-template-columns: 1fr 1fr;
                 gap: 1rem;
+                margin-top: 1rem;
             }
             .metric {
                 background: rgba(255, 255, 255, 0.05);
@@ -742,26 +520,13 @@ async def dashboard_optimise():
                 font-weight: bold;
                 color: #667eea;
             }
-            .metric-label {
-                font-size: 0.9rem;
-                opacity: 0.8;
-            }
-            .optimisation-badge {
-                background: linear-gradient(135deg, #4CAF50, #45a049);
-                padding: 0.3rem 0.8rem;
-                border-radius: 15px;
-                font-size: 0.8rem;
-                display: inline-block;
-                margin: 0.2rem;
-            }
-            .chat-section {
-                grid-column: 1 / -1;
+            .chat-container {
                 background: rgba(255, 255, 255, 0.1);
                 border-radius: 15px;
                 padding: 1.5rem;
                 display: flex;
                 flex-direction: column;
-                height: 600px;
+                height: 500px;
             }
             .chat-messages {
                 flex: 1;
@@ -805,8 +570,8 @@ async def dashboard_optimise():
                 color: white;
                 cursor: pointer;
             }
-            .performance-chart {
-                height: 300px;
+            canvas {
+                max-height: 300px;
             }
         </style>
     </head>
@@ -814,295 +579,88 @@ async def dashboard_optimise():
         <div class="container">
             <div class="header">
                 <h1>🧠 Barouia-Cortex 3.0</h1>
-                <p>Système IA Avancé avec Optimisations Intelligentes</p>
-                <div class="version">Version 3.0 - Compression Token • Mémoire Optimisée • Entraînement Accéléré</div>
+                <p>Système IA avec Optimisations Intelligentes</p>
             </div>
             
-            <div class="dashboard-grid">
-                <!-- Carte Performance Globale -->
+            <div class="dashboard">
                 <div class="card">
                     <h3>⚡ Performance Globale</h3>
                     <div class="metrics-grid">
                         <div class="metric">
                             <div class="metric-value" id="tempsReponse">0.05s</div>
-                            <div class="metric-label">Temps Réponse</div>
+                            <div>Temps Réponse</div>
                         </div>
                         <div class="metric">
                             <div class="metric-value" id="precision">95%</div>
-                            <div class="metric-label">Précision</div>
+                            <div>Précision</div>
                         </div>
                         <div class="metric">
                             <div class="metric-value" id="compression">65%</div>
-                            <div class="metric-label">Compression</div>
+                            <div>Compression</div>
                         </div>
                         <div class="metric">
                             <div class="metric-value" id="vitesse">1.0x</div>
-                            <div class="metric-label">Vitesse</div>
+                            <div>Vitesse</div>
                         </div>
                     </div>
                 </div>
                 
-                <!-- Carte Mémoire Optimisée -->
                 <div class="card">
                     <h3>💾 Mémoire Optimisée</h3>
                     <div class="metrics-grid">
                         <div class="metric">
                             <div class="metric-value" id="memoireUtilisee">0</div>
-                            <div class="metric-label">Éléments Stockés</div>
-                        </div>
-                        <div class="metric">
-                            <div class="metric-value" id="tauxCompression">0%</div>
-                            <div class="metric-label">Taux Compression</div>
-                        </div>
-                        <div class="metric">
-                            <div class="metric-value" id="accesMemoire">0</div>
-                            <div class="metric-label">Accès Mémoire</div>
+                            <div>Éléments</div>
                         </div>
                         <div class="metric">
                             <div class="metric-value" id="cacheActif">0</div>
-                            <div class="metric-label">Cache Actif</div>
+                            <div>Cache</div>
                         </div>
                     </div>
                 </div>
-                
-                <!-- Carte Entraînement Accéléré -->
-                <div class="card">
-                    <h3>🎯 Entraînement Accéléré</h3>
-                    <div class="metrics-grid">
-                        <div class="metric">
-                            <div class="metric-value" id="cyclesEntrainement">0</div>
-                            <div class="metric-label">Cycles</div>
-                        </div>
-                        <div class="metric">
-                            <div class="metric-value" id="vitesseEntrainement">1.0x</div>
-                            <div class="metric-label">Vitesse</div>
-                        </div>
-                        <div class="metric">
-                            <div class="metric-value" id="performanceMoyenne">0%</div>
-                            <div class="metric-label">Performance</div>
-                        </div>
-                        <div class="metric">
-                            <div class="metric-value" id="erreursEvitees">0</div>
-                            <div class="metric-label">Erreurs Évitée
-                            # =============================================================================
-# SUITE DU CODE - INTERFACE DASHBOARD OPTIMISÉE
-# =============================================================================
-
             </div>
-                    <div class="optimisations-actives">
-                        <div class="optimisation-badge">Compression Token</div>
-                        <div class="optimisation-badge">Cache Intelligent</div>
-                        <div class="optimisation-badge">LRU Optimisé</div>
-                    </div>
-                </div>
-                
-                <!-- Carte Contexte Étendu -->
-                <div class="card">
-                    <h3>🪟 Contexte Étendu</h3>
-                    <div class="metrics-grid">
-                        <div class="metric">
-                            <div class="metric-value" id="tailleContexte">0</div>
-                            <div class="metric-label">Éléments</div>
-                        </div>
-                        <div class="metric">
-                            <div class="metric-value" id="contexteCompresse">0</div>
-                            <div class="metric-label">Compressés</div>
-                        </div>
-                        <div class="metric">
-                            <div class="metric-value" id="importanceMoyenne">0</div>
-                            <div class="metric-label">Importance</div>
-                        </div>
-                        <div class="metric">
-                            <div class="metric-value" id="tokensDisponibles">2000</div>
-                            <div class="metric-label">Tokens Max</div>
+            
+            <div class="card">
+                <h3>💬 Interface Optimisée</h3>
+                <div class="chat-container">
+                    <div class="chat-messages" id="chatMessages">
+                        <div class="message ai-message">
+                            🧠 <strong>Barouia-Cortex 3.0</strong> initialisé!<br>
+                            ⚡ Compression Token activée<br>
+                            💾 Mémoire optimisée fonctionnelle
                         </div>
                     </div>
-                </div>
-                
-                <!-- Graphique Performance -->
-                <div class="card" style="grid-column: span 2;">
-                    <h3>📈 Performance en Temps Réel</h3>
-                    <div class="performance-chart">
-                        <canvas id="performanceChart"></canvas>
-                    </div>
-                </div>
-                
-                <!-- Graphique Compression -->
-                <div class="card">
-                    <h3>🔧 Efficacité Compression</h3>
-                    <div class="performance-chart">
-                        <canvas id="compressionChart"></canvas>
-                    </div>
-                </div>
-            </div>
-            
-            <!-- Section Chat Optimisé -->
-            <div class="chat-section">
-                <h3>💬 Interface de Communication Optimisée</h3>
-                <div class="chat-messages" id="chatMessages">
-                    <div class="message ai-message">
-                        🧠 <strong>Barouia-Cortex 3.0</strong> initialisé avec succès!<br>
-                        ⚡ <em>Système d'optimisation active:</em> Compression Token, Mémoire Intelligente, Entraînement Accéléré<br>
-                        💾 <em>Statut:</em> Prêt pour les requêtes haute performance
+                    <div class="chat-input">
+                        <input type="text" id="messageInput" placeholder="Tapez votre message..." autocomplete="off">
+                        <button id="sendButton">Envoyer</button>
                     </div>
                 </div>
-                <div class="chat-input">
-                    <input type="text" id="messageInput" placeholder="Tapez votre message (optimisation automatique activée)..." autocomplete="off">
-                    <button id="sendButton">Envoyer 🚀</button>
-                </div>
             </div>
         </div>
 
         <script>
-            let conversationId = null;
-            let performanceChart = null;
-            let compressionChart = null;
-            let statsHistory = [];
-            
-            // Initialisation des graphiques
-            function initializeCharts() {
-                // Graphique de performance
-                const perfCtx = document.getElementById('performanceChart').getContext('2d');
-                performanceChart = new Chart(perfCtx, {
-                    type: 'line',
-                    data: {
-                        labels: [],
-                        datasets: [
-                            {
-                                label: 'Temps Réponse (ms)',
-                                data: [],
-                                borderColor: 'rgba(102, 126, 234, 1)',
-                                backgroundColor: 'rgba(102, 126, 234, 0.1)',
-                                tension: 0.4,
-                                yAxisID: 'y'
-                            },
-                            {
-                                label: 'Précision (%)',
-                                data: [],
-                                borderColor: 'rgba(75, 192, 192, 1)',
-                                backgroundColor: 'rgba(75, 192, 192, 0.1)',
-                                tension: 0.4,
-                                yAxisID: 'y1'
-                            }
-                        ]
-                    },
-                    options: {
-                        scales: {
-                            y: {
-                                type: 'linear',
-                                display: true,
-                                position: 'left',
-                                title: { display: true, text: 'Temps (ms)' },
-                                min: 0,
-                                max: 100
-                            },
-                            y1: {
-                                type: 'linear',
-                                display: true,
-                                position: 'right',
-                                title: { display: true, text: 'Précision (%)' },
-                                min: 0,
-                                max: 100,
-                                grid: { drawOnChartArea: false }
-                            }
-                        }
-                    }
-                });
-                
-                // Graphique de compression
-                const compCtx = document.getElementById('compressionChart').getContext('2d');
-                compressionChart = new Chart(compCtx, {
-                    type: 'bar',
-                    data: {
-                        labels: ['Compression', 'Économie', 'Efficacité'],
-                        datasets: [{
-                            label: 'Taux (%)',
-                            data: [65, 45, 85],
-                            backgroundColor: [
-                                'rgba(102, 126, 234, 0.8)',
-                                'rgba(75, 192, 192, 0.8)',
-                                'rgba(153, 102, 255, 0.8)'
-                            ]
-                        }]
-                    },
-                    options: {
-                        scales: {
-                            y: { beginAtZero: true, max: 100 }
-                        }
-                    }
-                });
-            }
-            
-            // Mise à jour des métriques en temps réel
+            // Mise à jour des métriques
             async function updateMetrics() {
                 try {
                     const response = await fetch('/api/statistiques/avancees');
                     const data = await response.json();
                     
-                    // Métriques de performance globale
                     const perf = data.etat_cortex.performance_globale;
                     document.getElementById('tempsReponse').textContent = (perf.temps_reponse * 1000).toFixed(1) + 'ms';
                     document.getElementById('precision').textContent = perf.precision.toFixed(1) + '%';
                     document.getElementById('compression').textContent = perf.efficacite_memoire.toFixed(1) + '%';
                     document.getElementById('vitesse').textContent = perf.vitesse_traitement.toFixed(1) + 'x';
                     
-                    // Métriques mémoire
                     const mem = data.statistiques_memoire;
-                    document.getElementById('memoireUtilisee').textContent = mem.utilisation.toLocaleString();
-                    document.getElementById('tauxCompression').textContent = mem.taux_compression_moyen.toFixed(1) + '%';
-                    document.getElementById('accesMemoire').textContent = mem.acces_total.toLocaleString();
-                    document.getElementById('cacheActif').textContent = mem.elements_caches.toLocaleString();
-                    
-                    // Métriques entraînement
-                    const ent = data.performance_entrainement;
-                    document.getElementById('cyclesEntrainement').textContent = ent.cycles_entrainement.toLocaleString();
-                    document.getElementById('vitesseEntrainement').textContent = ent.vitesse_actuelle.toFixed(1) + 'x';
-                    document.getElementById('performanceMoyenne').textContent = 
-                        ent.performance_history.length > 0 ? 
-                        (ent.performance_history[ent.performance_history.length - 1].accuracy * 100).toFixed(1) + '%' : '0%';
-                    document.getElementById('erreursEvitees').textContent = data.etat_cortex.statistiques_avancees.erreurs_evitees.toLocaleString();
-                    
-                    // Métriques contexte
-                    const ctx = data.fenetre_contexte;
-                    document.getElementById('tailleContexte').textContent = ctx.taille_actuelle.toLocaleString();
-                    document.getElementById('contexteCompresse').textContent = ctx.elements_compresses.toLocaleString();
-                    document.getElementById('importanceMoyenne').textContent = 
-                        Object.keys(ctx.scores_importance).length > 0 ? 'Élevée' : 'Normale';
-                    
-                    // Mise à jour des graphiques
-                    updateCharts(data);
+                    document.getElementById('memoireUtilisee').textContent = mem.utilisation;
+                    document.getElementById('cacheActif').textContent = mem.elements_caches;
                     
                 } catch (error) {
-                    console.error('Erreur mise à jour métriques:', error);
+                    console.error('Erreur mise à jour:', error);
                 }
             }
             
-            // Mise à jour des graphiques
-            function updateCharts(data) {
-                // Historique des performances
-                const history = data.historique_performances || [];
-                if (history.length > 0) {
-                    const labels = history.map((_, i) => i);
-                    const tempsReponse = history.map(h => (h.temps_reponse * 1000).toFixed(1));
-                    const precision = history.map(h => h.performance);
-                    
-                    performanceChart.data.labels = labels;
-                    performanceChart.data.datasets[0].data = tempsReponse;
-                    performanceChart.data.datasets[1].data = precision;
-                    performanceChart.update();
-                }
-                
-                // Graphique de compression
-                const stats = data.etat_cortex.statistiques_avancees;
-                compressionChart.data.datasets[0].data = [
-                    stats.economie_memoire,
-                    Math.min(100, stats.economie_memoire * 1.3),
-                    Math.min(100, stats.economie_memoire * 1.1)
-                ];
-                compressionChart.update();
-            }
-            
-            // Gestion du chat optimisé
+            // Gestion du chat
             async function sendMessage() {
                 const input = document.getElementById('messageInput');
                 const message = input.value.trim();
@@ -1116,24 +674,19 @@ async def dashboard_optimise():
                     const response = await fetch('/api/chat/optimise', {
                         method: 'POST',
                         headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({
-                            message: message,
-                            conversation_id: conversationId || 'optimise-v3',
-                            optimisations: true
-                        })
+                        body: JSON.stringify({ message: message })
                     });
                     
                     const data = await response.json();
                     
                     if (data.success) {
                         addMessage('ai', data.reponse);
-                        // Mise à jour immédiate des métriques
                         updateMetrics();
                     } else {
-                        addMessage('ai', '❌ Erreur: ' + (data.error || 'inconnue'));
+                        addMessage('ai', 'Erreur: ' + data.error);
                     }
                 } catch (error) {
-                    addMessage('ai', '❌ Erreur de connexion au serveur');
+                    addMessage('ai', 'Erreur de connexion');
                 }
             }
             
@@ -1141,76 +694,11 @@ async def dashboard_optimise():
                 const container = document.getElementById('chatMessages');
                 const messageDiv = document.createElement('div');
                 messageDiv.className = `message ${role}-message`;
-                
-                if (role === 'ai') {
-                    // Formatage des réponses IA
-                    messageDiv.innerHTML = formatAIResponse(content);
-                } else {
-                    messageDiv.textContent = content;
-                }
-                
+                messageDiv.innerHTML = content;
                 container.appendChild(messageDiv);
                 container.scrollTop = container.scrollHeight;
             }
             
-            function formatAIResponse(content) {
-                // Mise en forme avancée des réponses IA
-                return content
-                    .replace(/🧠/g, '<span style="color: #667eea">🧠</span>')
-                    .replace(/⚡/g, '<span style="color: #ffd700">⚡</span>')
-                    .replace(/💾/g, '<span style="color: #4CAF50">💾</span>')
-                    .replace(/🎯/g, '<span style="color: #ff6b6b">🎯</span>')
-                    .replace(/🪟/g, '<span style="color: #9c27b0">🪟</span>')
-                    .replace(/\n/g, '<br>')
-                    .replace(/\[(.*?)\]/g, '<strong>$1</strong>');
-            }
-            
-            // Simulation d'entraînement
-            async function demarrerEntrainement() {
-                try {
-                    const response = await fetch('/api/entrainement/demarrer', {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({
-                            donnees: [
-                                "Requête d'optimisation cognitive",
-                                "Demande de compression token avancée", 
-                                "Analyse de performance système",
-                                "Optimisation mémoire intelligente",
-                                "Gestion de contexte étendu"
-                            ],
-                            epochs: 5
-                        })
-                    });
-                    
-                    const result = await response.json();
-                    if (result.success) {
-                        addMessage('ai', '🎯 Entraînement accéléré terminé! Performance améliorée: ' + 
-                            result.resultat_entrainement.performance_moyenne.toFixed(2));
-                        updateMetrics();
-                    }
-                } catch (error) {
-                    console.error('Erreur entraînement:', error);
-                }
-            }
-            
-            // WebSocket pour les mises à jour temps réel
-            function connectWebSocket() {
-                const ws = new WebSocket(`ws://${window.location.host}/ws/optimise`);
-                
-                ws.onmessage = function(event) {
-                    const data = JSON.parse(event.data);
-                    if (data.type === 'reponse_optimisee') {
-                        addMessage('ai', data.reponse);
-                        updateMetrics();
-                    }
-                };
-                
-                ws.onclose = function() {
-                    setTimeout(connectWebSocket, 3000);
-                };
-            }
-            
             // Événements
             document.getElementById('sendButton').addEventListener('click', sendMessage);
             document.getElementById('messageInput').addEventListener('keypress', (e) => {
@@ -1219,16 +707,8 @@ async def dashboard_optimise():
             
             // Initialisation
             document.addEventListener('DOMContentLoaded', function() {
-                initializeCharts();
-                setInterval(updateMetrics, 2000); // Mise à jour toutes les 2 secondes
-                
-                // Démarrer un entraînement initial
-                setTimeout(demarrerEntrainement, 3000);
-                
-                // Connexion WebSocket
-                connectWebSocket();
-                
-                console.log('🚀 Barouia-Cortex 3.0 Dashboard initialisé');
+                setInterval(updateMetrics, 3000);
+                console.log('Barouia-Cortex 3.0 initialisé');
             });
         </script>
     </body>
@@ -1236,50 +716,6 @@ async def dashboard_optimise():
     """
     return HTMLResponse(content=html_content)
 
-# =============================================================================
-# FICHIER REQUIREMENTS.TXT OPTIMISÉ
-# =============================================================================
-
-"""
-fastapi==0.104.1
-uvicorn[standard]==0.24.0
-websockets==12.0
-numpy==1.24.3
-python-multipart==0.0.6
-python-dotenv==1.0.0
-aiohttp==3.9.1
-"""
-
-# =============================================================================
-# DOCKERFILE POUR HUGGING FACE SPACES
-# =============================================================================
-
-"""
-FROM python:3.9-slim
-
-WORKDIR /app
-
-# Installer les dépendances système
-RUN apt-get update && apt-get install -y \
-    gcc \
-    g++ \
-    && rm -rf /var/lib/apt/lists/*
-
-# Copier les requirements
-COPY requirements.txt .
-
-# Installer les dépendances Python
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copier l'application
-COPY . .
-
-# Exposer le port
-EXPOSE 7860
-
-# Démarrer l'application
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
-
 if __name__ == "__main__":
     port = int(os.getenv("PORT", 7860))
     uvicorn.run(app, host="0.0.0.0", port=port)