Update app.py

app.py

@@ -43,64 +43,52 @@ def predict_patterns(data, future_hours=24):
     cycle_amplitude = (df["price"].max() - df["price"].min()) / 2
     mean_price = df["price"].mean()
 
-    patterns = {}
-
-    patterns["Trend"] = [last_price + i * trend for i in range(1, len(future_timestamps) + 1)]
-    patterns["Reversal"] = [last_price - i * trend for i in range(1, len(future_timestamps) + 1)]
-    patterns["SMA"] = [sma] * len(future_timestamps)
-    patterns["EMA"] = [ema] * len(future_timestamps)
-    patterns["Cycle"] = [
-        last_price + cycle_amplitude * np.sin(2 * np.pi * i / len(future_timestamps))
-        for i in range(len(future_timestamps))
-    ]
-    patterns["Rebound"] = [last_price + trend * (0.5 ** i) for i in range(len(future_timestamps))]
-    patterns["Plateau"] = [last_price] * len(future_timestamps)
-    patterns["Breakout"] = [
-        last_price + (trend * 2 if i < len(future_timestamps) // 2 else -trend * 2)
-        for i in range(len(future_timestamps))
-    ]
-    patterns["Recovery"] = [last_price + (mean_price - last_price) * (i / len(future_timestamps)) for i in range(len(future_timestamps))]
-    patterns["Acceleration"] = [last_price + (trend * 1.5) * i for i in range(len(future_timestamps))]
-
-    # Ajout des 20 autres patterns
-    patterns["Overbought"] = [last_price + cycle_amplitude * np.cos(2 * np.pi * i / len(future_timestamps)) for i in range(len(future_timestamps))]
-    patterns["Oversold"] = [last_price - cycle_amplitude * np.cos(2 * np.pi * i / len(future_timestamps)) for i in range(len(future_timestamps))]
-    patterns["DoubleTop"] = [last_price + trend * 2 if i < len(future_timestamps) // 2 else last_price - trend * 2 for i in range(len(future_timestamps))]
-    patterns["DoubleBottom"] = [last_price - trend * 2 if i < len(future_timestamps) // 2 else last_price + trend * 2 for i in range(len(future_timestamps))]
-    patterns["HeadAndShoulders"] = [last_price + (cycle_amplitude * np.sin(2 * np.pi * i / (len(future_timestamps) // 2))) for i in range(len(future_timestamps))]
-    patterns["InverseHeadAndShoulders"] = [last_price - (cycle_amplitude * np.sin(2 * np.pi * i / (len(future_timestamps) // 2))) for i in range(len(future_timestamps))]
-    patterns["Parabolic"] = [last_price + (cycle_amplitude * i ** 2) for i in range(len(future_timestamps))]
-    patterns["ExponentialGrowth"] = [last_price * (1 + 0.05) ** i for i in range(len(future_timestamps))]
-    patterns["ExponentialDecay"] = [last_price * (1 - 0.05) ** i for i in range(len(future_timestamps))]
-    patterns["Sinusoidal"] = [last_price + cycle_amplitude * np.sin(2 * np.pi * i / len(future_timestamps)) for i in range(len(future_timestamps))]
-    patterns["Flatline"] = [last_price for i in range(len(future_timestamps))]
-    patterns["HarmonicOscillator"] = [last_price + cycle_amplitude * np.cos(2 * np.pi * i / len(future_timestamps)) for i in range(len(future_timestamps))]
-    patterns["Waveform"] = [last_price + cycle_amplitude * np.sin(i) for i in range(len(future_timestamps))]
-    patterns["SwingHigh"] = [last_price + cycle_amplitude * np.sin(2 * np.pi * i / len(future_timestamps)) for i in range(len(future_timestamps))]
-    patterns["SwingLow"] = [last_price - cycle_amplitude * np.sin(2 * np.pi * i / len(future_timestamps)) for i in range(len(future_timestamps))]
-    patterns["AscendingTriangle"] = [last_price + cycle_amplitude * np.exp(i / len(future_timestamps)) for i in range(len(future_timestamps))]
-    patterns["DescendingTriangle"] = [last_price - cycle_amplitude * np.exp(i / len(future_timestamps)) for i in range(len(future_timestamps))]
-
-    pattern_dfs = {
-        pattern_name: pd.DataFrame({"timestamp": future_timestamps, "price": prices})
-        for pattern_name, prices in patterns.items()
+    # Prédictions initiales (Courbe jaune)
+    predictions = {
+        "Trend": [last_price + i * trend for i in range(1, len(future_timestamps) + 1)],
+        "SMA": [sma] * len(future_timestamps),
+        "EMA": [ema] * len(future_timestamps),
+        "Cycle": [
+            last_price + cycle_amplitude * np.sin(2 * np.pi * i / len(future_timestamps))
+            for i in range(len(future_timestamps))
+        ]
     }
-    return pattern_dfs
 
-# Fonction pour identifier le pattern le plus ressemblant
-def identify_best_pattern(df, patterns):
+    return predictions, future_timestamps
+
+# Fonction pour rechercher un pattern similaire
+def find_similar_pattern(df, prediction, future_hours=24):
+    # Calculer la similarité entre la courbe prédite et les patterns passés
     mse_scores = {}
-    actual_values = df["price"].values[-len(df) // 2:]  # Dernières heures
+    for i in range(len(df) - future_hours):  # Exclure la dernière période pour éviter la correspondance avec elle-même
+        past_pattern = df["price"].iloc[i:i + future_hours].values
+        mse = mean_squared_error(past_pattern, prediction[:len(past_pattern)])
+        mse_scores[i] = mse
+
+    # Trouver l'indice du pattern le plus similaire
+    best_match_index = min(mse_scores, key=mse_scores.get)
+    similar_pattern = df["price"].iloc[best_match_index:best_match_index + future_hours].values
+    return similar_pattern
+
+# Fonction pour générer une prédiction dynamique (Courbe verte)
+def generate_dynamic_prediction(df, initial_prediction, future_hours=24):
+    green_prediction = []
+
+    # Première prédiction
+    green_prediction.extend(initial_prediction)
+
+    # Boucle pour ajuster la prédiction à chaque étape
+    for i in range(future_hours // 5):  # Prédiction par segments de 5 heures
+        start_idx = i * 5
+        end_idx = (i + 1) * 5
 
-    for pattern_name, pattern_df in patterns.items():
-        predicted_values = np.array(pattern_df["price"].values[:len(actual_values)])
-        min_length = min(len(actual_values), len(predicted_values))
-        mse = mean_squared_error(actual_values[:min_length], predicted_values[:min_length])
-        mse_scores[pattern_name] = mse
+        # Prendre les 5 dernières valeurs et chercher un pattern similaire
+        similar_pattern = find_similar_pattern(df, green_prediction[start_idx:end_idx], future_hours=5)
 
-    # Sélection du pattern avec la MSE la plus faible
-    best_pattern = min(mse_scores, key=mse_scores.get)
-    return best_pattern
+        # Ajouter le pattern similaire à la prédiction
+        green_prediction.extend(similar_pattern)
+
+    return green_prediction
 
 # Configuration des dates
 end_time = datetime.now()
@@ -125,24 +113,27 @@ for coin, price_data in crypto_prices.items():
         df = pd.DataFrame(price_data, columns=["timestamp", "price"])
         df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
 
-        patterns = predict_patterns(price_data, future_hours=24)
-        best_pattern = identify_best_pattern(df, patterns)
+        # Générer les prédictions initiales (jaune)
+        predictions, future_timestamps = predict_patterns(price_data, future_hours=24)
+        
+        # Sélectionner une prédiction (par exemple Trend)
+        initial_prediction = predictions["Trend"]
+
+        # Générer la prédiction dynamique (verte)
+        green_prediction = generate_dynamic_prediction(df, initial_prediction, future_hours=24)
 
+        # Affichage des résultats
         st.write(f"#### {coin} - Prix et Prédictions")
         fig, ax = plt.subplots(figsize=(12, 6))
         ax.plot(df["timestamp"], df["price"], label="Prix réel", color="blue")
 
-        # Affiche uniquement le meilleur pattern
-        best_pattern_df = patterns[best_pattern]
-        ax.plot(
-            best_pattern_df["timestamp"],
-            best_pattern_df["price"],
-            label=f"Prédiction ({best_pattern})",
-            linestyle="dashed",
-            color="orange"
-        )
-
-        ax.set_title(f"{coin} - Prix (7 derniers jours + 24h prévus avec {best_pattern})")
+        # Courbe de prédiction initiale (jaune)
+        ax.plot(future_timestamps, initial_prediction, label="Prédiction initiale (jaune)", linestyle="--", color="yellow")
+
+        # Courbe de prédiction dynamique (verte)
+        ax.plot(future_timestamps, green_prediction, label="Prédiction dynamique (verte)", linestyle="--", color="green")
+
+        ax.set_title(f"{coin} - Prix (7 derniers jours + 24h prévus)")
         ax.set_xlabel("Date")
         ax.set_ylabel("Prix (USD)")
         ax.legend()