Update app.py

app.py

@@ -124,12 +124,19 @@ def restore_db_from_hf():
         print(f"⚠️ Aucun backup ADN trouvé (1er lancement) : {e}")
 
     # 2. Tentative de restauration du modèle DINO
-    try:
-        print("🔄 [SYSTEM] Restauration du DINO depuis HF...")
-        hf_hub_download(repo_id=DATASET_REPO_ID, filename="dino_lgbm_model.txt", repo_type="dataset", local_dir=".", token=HF_TOKEN)
-        print("✅ [RESTORE] Modèle Dino récupéré !")
-    except Exception:
-        print("⚠️ Aucun modèle Dino trouvé dans le backup. Pense à Forcer l'Entraînement.")
+    # 2. Tentative de restauration des modèles DINO (Multiples)
+    global dino_brains
+    dino_brains = {}
+    
+    for crypto in ["BTC", "ETH"]:
+        filename = f"dino_lgbm_{crypto}.txt"
+        try:
+            print(f"🔄 [SYSTEM] Restauration du DINO {crypto} depuis HF...")
+            hf_hub_download(repo_id=HF_REPO_ID, filename=filename, repo_type="dataset", local_dir=".", token=HF_TOKEN)
+            dino_brains[crypto] = lgb.Booster(model_file=filename)
+            print(f"✅ [RESTORE] Modèle Dino {crypto} récupéré et chargé !")
+        except Exception:
+            print(f"⚠️ Aucun modèle trouvé pour {crypto}. Pense à Forcer l'Entraînement de {crypto}.")
 
 def backup_db_to_hf():
     if not HF_TOKEN: return
@@ -367,8 +374,15 @@ async def predict_signal(symbol, timeframe="1h"):
         ml_prob = float(ml_model.predict_proba(last_row[ml_cols])[0][1])
         time_cols = ['return_1h', 'return_3h', 'return_12h', 'RSI_lag1', 'RSI_lag2', 'vol_lag1', 'VOL_RATIO']
         time_prob = float(time_model.predict_proba(last_row[time_cols])[0][1])
-        dino_prob = float(dino_brain.predict(last_row[ml_cols].values)[0]) if dino_brain else 0.5
-
+        
+        # 🧠 SÉLECTION DU CERVEAU DINO (Schizophrénie)
+        sym_clean = symbol.replace("/", "").replace("USDT", "").replace("USD", "").upper()
+        if 'dino_brains' in globals() and sym_clean in dino_brains:
+            dino_prob = float(dino_brains[sym_clean].predict(last_row[ml_cols].values)[0])
+        elif 'dino_brain' in globals() and dino_brain: # Sécurité : Fallback sur l'ancien modèle si besoin
+            dino_prob = float(dino_brain.predict(last_row[ml_cols].values)[0])
+        else:
+            dino_prob = 0.5 # Si aucun cerveau n'est entraîné, on reste neutre
         # ⚡ 4. ENSEMBLE V30
         final_p, wt, wm, wl, ws = combine_scores(symbol, timeframe, time_prob, ml_prob, dino_prob, p_sent, final_scenario)
 
@@ -792,16 +806,25 @@ def detect_chart_scenario(df, df_1m=None, df_5m=None, df_15m=None, df_1h=None):
         return 3
 
     
+# --- 🧠 TRAINING ENGINE ---
 # --- 🧠 TRAINING ENGINE ---
 def trigger_training(symbol="BTC/USD"):
     try:
         memory_guard()
+        
+        # 🎯 1. Nettoyage du symbole pour le nom de fichier (ex: BTC/USDT -> BTC)
+        sym_clean = symbol.replace("/", "").replace("USDT", "").replace("USD", "").upper()
+        if not sym_clean: sym_clean = "DEFAULT"
+        
+        # On crée un nom de fichier unique par crypto
+        model_filename = f"dino_lgbm_{sym_clean}.txt"
+
         bars = exchange_sync.fetch_ohlcv(symbol, timeframe='1h', limit=1500)
         df = pd.DataFrame(bars, columns=['ts', 'open', 'high', 'low', 'close', 'vol'])
-        if len(df) < 500: return f"❌ Historique insuffisant."
+        if len(df) < 500: return f"❌ Historique insuffisant pour {symbol}."
         
         df_final = prepare_features_sync(symbol, '1h', limit_bars=1000)
-        if df_final.empty or len(df_final) < 100: return f"❌ Données vides."
+        if df_final.empty or len(df_final) < 100: return f"❌ Données vides pour {symbol}."
 
         if LGBM_AVAILABLE:
             ml_cols = ["RSI", "Dist_High_24h", "Dist_Low_24h", "EMA_dist", "EMA_slope", "ATR_ratio", "VOL_ratio"]
@@ -809,28 +832,43 @@ def trigger_training(symbol="BTC/USD"):
             df_train = df_final.dropna(subset=ml_cols + ['Target'])
             X, y = df_train[ml_cols], df_train['Target']
             params = {'objective': 'binary', 'metric': 'binary_logloss', 'boosting_type': 'gbdt', 'learning_rate': 0.05, 'num_leaves': 31, 'verbose': -1}
+            
             model = lgb.train(params, lgb.Dataset(X, label=y), 100)
-            model.save_model('dino_lgbm_model.txt')
+            
+            # 💾 2. Sauvegarde avec le nom unique
+            model.save_model(model_filename)
+            
             try:
                 api = HfApi()
                 api.upload_file(
-                    path_or_fileobj="dino_lgbm_model.txt",
-                    path_in_repo="dino_lgbm_model.txt",
-                    repo_id=HF_REPO_ID, # Utilise la même variable que pour ton .db
+                    path_or_fileobj=model_filename,
+                    path_in_repo=model_filename,
+                    repo_id=HF_REPO_ID, 
                     repo_type="dataset",
                     token=HF_TOKEN
                 )
-                print("☁️ [BACKUP] dino_lgbm_model.txt sauvegardé sur le Cloud !")
+                print(f"☁️ [BACKUP] {model_filename} sauvegardé sur le Cloud !")
             except Exception as e:
-                print(f"⚠️ Erreur backup modèle : {e}")
-            global dino_brain
-            dino_brain = lgb.Booster(model_file='dino_lgbm_model.txt')
-
+                print(f"⚠️ Erreur backup modèle {sym_clean} : {e}")
+            
+            # 🧠 3. On met à jour le dictionnaire global des cerveaux DINO
+            global dino_brains
+            if 'dino_brains' not in globals():
+                dino_brains = {}
+            dino_brains[sym_clean] = lgb.Booster(model_file=model_filename)
+            print(f"🧠 [IA] Cerveau {sym_clean} chargé en mémoire vive.")
+
+        # Ces deux là restent uniques car ils sont sûrement génériques dans ton code
         global ml_model, time_model
-        ml_model, time_model = joblib.load("ml_model_v9.pkl"), joblib.load("time_model.pkl")
+        try:
+            ml_model, time_model = joblib.load("ml_model_v9.pkl"), joblib.load("time_model.pkl")
+        except: pass # Si les pkl n'existent pas, on ne crashe pas tout
+        
         gc.collect()
-        return f"✅ IA ré-entraînée."
-    except Exception as e: return f"❌ Erreur Training : {e}"
+        return f"✅ IA ré-entraînée et sauvegardée pour {symbol} ({model_filename})."
+    except Exception as e: return f"❌ Erreur Training {symbol} : {e}"
+
+def training_wrapper(symbol, *args): return trigger_training(str(symbol).strip().upper() if isinstance(symbol, str) else "BTC/USDT")
 
 # --- 🚀 MOTEURS AUTO-PILOTE ---
 AUTO_SYMBOLS = ["BTC/USD", "ETH/USD"]