#!/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é """ from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect from fastapi.responses import HTMLResponse, JSONResponse from fastapi.middleware.cors import CORSMiddleware from pydantic import BaseModel import uvicorn import logging import json import uuid import time import os import asyncio from typing import Dict, List, Optional, Tuple, Any import numpy as np from datetime import datetime, timedelta import hashlib import zlib import base64 from collections import deque, defaultdict import re # Configuration du logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') logger = logging.getLogger("barouia_cortex_3") # ============================================================================= # NOUVEAU SYSTÈME DE COMPRESSION DE TOKENS # ============================================================================= class TokenCompressor: """Système avancé de compression lexicale - Faire plus avec moins de tokens""" def __init__(self): self.dictionnaire_compresse = {} self.dictionnaire_decompresse = {} self.mots_frequents = self.charger_mots_frequents() self.compression_level = 12 # Niveau de compression maximal logger.info("🔤 Compresseur Token initialisé") def charger_mots_frequents(self) -> Dict[str, int]: """Charge les mots fréquents du français pour l'optimisation""" 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' } 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""" 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') 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: logger.error(f"❌ Erreur compression: {e}") return texte, 0.0 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 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 # ============================================================================= class MemoireCompressee: """Système de mémoire avec compression et cache intelligent""" def __init__(self, capacite_max: int = 1000000): self.capacite_max = capacite_max self.memoire_principale = {} self.cache_actif = deque(maxlen=1000) # Cache LRU self.historique_acces = defaultdict(int) 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""" 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 ) else: valeur_compressee = valeur self.memoire_principale[cle] = { 'valeur': valeur_compressee, 'type': 'texte' if isinstance(valeur, str) else 'autre', 'timestamp': time.time(), 'acces': 0 } # Mettre à jour le cache self.mettre_a_jour_cache(cle) return True except Exception as e: logger.error(f"❌ Erreur stockage: {e}") return False def recuperer(self, cle: str) -> Optional[Any]: """Récupère une valeur avec décompression automatique""" 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: logger.error(f"❌ Erreur récupération: {e}") return None def liberer_espace(self): """Libère de l'espace en supprimant les éléments les moins utilisés""" 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""" if cle in self.cache_actif: self.cache_actif.remove(cle) self.cache_actif.append(cle) def get_statistiques(self) -> Dict[str, Any]: """Retourne les statistiques de la mémoire""" 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) } # ============================================================================= # MOTEUR D'ENTRAÎNEMENT ACCÉLÉRÉ # ============================================================================= class MoteurEntrainement: """Système d'entraînement neuronal accéléré avec optimisation mémoire""" 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""" 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 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 } except Exception as e: logger.error(f"❌ Erreur entraînement: {e}") return {"success": False, "error": str(e)} 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 return { "epoch": epoch, "accuracy": accuracy, "loss": loss, "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]: """Retourne les statistiques d'entraînement""" return { "cycles_entrainement": self.cycles_entrainement, "vitesse_actuelle": self.vitesse_entrainement, "performance_history": list(self.performance_history), "memoire_entrainement": self.memoire_entrainement.get_statistiques() } # ============================================================================= # FENÊTRE DE CONTEXTE ÉTENDUE INTELLIGENTE # ============================================================================= class FenetreContexteEtendue: """Système de fenêtre de contexte étendue avec gestion intelligente""" def __init__(self, taille_max: int = 10000, compression_auto: bool = True): 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() 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 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) } # ============================================================================= # CORTEX OPTIMISÉ 3.0 # ============================================================================= 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) logger.info("🧠 Cortex Optimisé 3.0 initialisé") async def traiter_requete_optimisee(self, requete: str) -> Dict[str, Any]: """Traite une requête avec toutes les optimisations""" 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 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) return { "success": True, "reponse_originale": reponse, "reponse_compressee": reponse_compressee, "taux_compression": taux_compression, "temps_traitement": duree, "contexte_utilise": len(contexte) > 0 } except Exception as e: logger.error(f"❌ Erreur traitement optimisé: {e}") return {"success": False, "error": str(e)} 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 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. " ] 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)}" 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." 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}%" else: return f"{reponse_base} J'ai bien compris: '{requete}'. Comment puis-je vous aider davantage ?" def mettre_a_jour_statistiques(self, duree: float, taux_compression: float): """Met à jour les statistiques avancées""" self.etat["performance_globale"]["temps_reponse"] = ( 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"] }) def get_statistiques_completes(self) -> Dict[str, Any]: """Retourne toutes les statistiques du système""" return { "etat_cortex": self.etat, "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 # ============================================================================= app = FastAPI( title="Barouia-Cortex 3.0", description="Système IA avancé avec compression token et optimisation mémoire", version="3.0.0" ) app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) # Initialisation du système optimisé 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 # Routes API optimisées
@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" ] }
@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"] }
@app .get("/api/statistiques/avancees") async def get_statistiques_avancees(): return cortex_optimise.get_statistiques_completes()
@app .post("/api/chat/optimise") async def chat_optimise(request: ChatRequest): """Endpoint de chat avec toutes les 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}"} 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") async def demarrer_entrainement(request: EntrainementRequest): """Démarre un cycle d'entraînement optimisé""" try: 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() } 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""" await websocket.accept() try: while True: data = await websocket.receive_text() message_data = json.loads(data) resultat = await cortex_optimise.traiter_requete_optimisee( message_data.get("message", "") ) await websocket.send_json({ "type": "reponse_optimisee", "reponse": resultat.get("reponse_originale", ""), "statistiques": resultat, "cortex_state": cortex_optimise.get_statistiques_completes() }) except WebSocketDisconnect: logger.info("WebSocket optimisé déconnecté") # Interface dashboard optimisée
@app .get("/dashboard", response_class=HTMLResponse) async def dashboard_optimise(): html_content = """ <!DOCTYPE html> <html lang="fr"> <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> <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; background: linear-gradient(135deg, #0f0f23 0%, #1a1a2e 100%); color: white; min-height: 100vh; padding: 20px; } .container { max-width: 1400px; margin: 0 auto; } .header { text-align: center; padding: 2rem; background: linear-gradient(135deg, #667eea, #764ba2); 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 { display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 1.5rem; margin-bottom: 2rem; }
@media (max-width: 1200px) { .dashboard-grid { grid-template-columns: 1fr 1fr; } }
@media (max-width: 768px) { .dashboard-grid { grid-template-columns: 1fr; } } .card { background: rgba(255, 255, 255, 0.1); padding: 1.5rem; 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; } .metric { background: rgba(255, 255, 255, 0.05); padding: 1rem; border-radius: 10px; text-align: center; } .metric-value { font-size: 1.5rem; 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; background: rgba(255, 255, 255, 0.1); border-radius: 15px; padding: 1.5rem; display: flex; flex-direction: column; height: 600px; } .chat-messages { flex: 1; overflow-y: auto; padding: 1rem; margin-bottom: 1rem; border: 1px solid rgba(255, 255, 255, 0.2); border-radius: 10px; } .message { margin: 0.5rem 0; padding: 0.75rem; border-radius: 10px; max-width: 80%; } .user-message { background: linear-gradient(135deg, #667eea, #764ba2); margin-left: auto; } .ai-message { background: rgba(255, 255, 255, 0.15); border: 1px solid rgba(102, 126, 234, 0.5); } .chat-input { display: flex; gap: 1rem; } #messageInput { flex: 1; padding: 0.75rem; border: none; border-radius: 25px; background: rgba(255, 255, 255, 0.1); color: white; } #sendButton { padding: 0.75rem 1.5rem; border: none; border-radius: 25px; background: linear-gradient(135deg, #667eea, #764ba2); color: white; cursor: pointer; } .performance-chart { height: 300px; } </style> </head> <body> <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> </div> <div class="dashboard-grid"> <!-- Carte Performance Globale --> <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> <div class="metric"> <div class="metric-value" id="precision">95%</div> <div class="metric-label">Précision</div> </div> <div class="metric"> <div class="metric-value" id="compression">65%</div> <div class="metric-label">Compression</div> </div> <div class="metric"> <div class="metric-value" id="vitesse">1.0x</div> <div class="metric-label">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> <div class="metric"> <div class="metric-value" id="cacheActif">0</div> <div class="metric-label">Cache Actif</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
