Update app.py

app.py

@@ -5,28 +5,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 from datetime import datetime, timedelta
 from sklearn.metrics import mean_squared_error
-import pandas as pd
-
-# Exemple de fonction pour identifier un pattern
-def identify_best_pattern(df, patterns):
-    # Logique de recherche du meilleur pattern
-    best_pattern = None  # Remplacez cette ligne par la logique réelle
-    return best_pattern
 
-# Exemple de dataframe (vous pouvez charger vos données ici)
-df = pd.DataFrame({
-    'date': ['2024-11-01', '2024-11-02', '2024-11-03'],
-    'price': [100, 110, 120]
-})
-
-# Exemple de patterns (vous pouvez ajuster selon vos besoins)
-patterns = [1, 2, 3]
-
-# Appel de la fonction
-best_pattern = identify_best_pattern(df, patterns)
-
-# Affichage du meilleur pattern trouvé
-print(best_pattern)
 # Fonction pour récupérer les prix historiques
 def get_crypto_prices(coins, start_time, end_time, interval='m15'):
     prices = {}
@@ -83,106 +62,87 @@ def predict_patterns(data, future_hours=24):
     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()
     }
     return pattern_dfs
 
-# Fonction pour identifier un pattern similaire dans l'historique
-def find_similar_pattern(df, pred_data, window_size=5):
+# Fonction pour identifier le pattern le plus ressemblant
+def identify_best_pattern(df, patterns):
     mse_scores = {}
-    for i in range(len(df) - window_size):
-        history_segment = df["price"].iloc[i:i + window_size].values
-        mse = mean_squared_error(history_segment, pred_data[:len(history_segment)])
-        mse_scores[i] = mse
-
-    # Trouver le segment avec le plus faible MSE
-    best_start_index = min(mse_scores, key=mse_scores.get)
-    similar_pattern = df["price"].iloc[best_start_index:best_start_index + window_size].values
-    return similar_pattern
-
-# Fonction pour générer une courbe dynamique basée sur les patterns passés
-def generate_dynamic_curve(df, initial_prediction, future_hours=24, window_size=5):
-    dynamic_curve = []
-    pred_data = initial_prediction[:window_size]  # Les premières données de la prédiction
-
-    # Générer une courbe en utilisant les patterns historiques de manière dynamique
-    for _ in range(future_hours // (window_size)):
-        similar_pattern = find_similar_pattern(df, pred_data, window_size)
-        dynamic_curve.extend(similar_pattern)  # Ajoute le pattern trouvé à la courbe
-        pred_data = similar_pattern  # Met à jour la prédiction avec le dernier pattern trouvé
+    actual_values = df["price"].values[-len(df) // 2:]  # Dernières heures
+
+    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
+
+    # Sélection du pattern avec la MSE la plus faible
+    best_pattern = min(mse_scores, key=mse_scores.get)
+    return best_pattern
 
+# Fonction pour ajouter la prédiction dynamique basée sur les patterns historiques
+def predict_dynamic_curve(df, patterns, future_hours=24):
+    dynamic_predictions = []
+    current_values = df["price"].values[-5:]  # Les 5 dernières valeurs pour démarrer
+
+    for i in range(future_hours // 5):
+        # Identifier le pattern le plus proche des 5 dernières valeurs
+        best_pattern = identify_best_pattern(pd.DataFrame({"timestamp": df.index[-5:], "price": current_values}), patterns)
+        best_pattern_values = patterns[best_pattern]["price"].values[:5]
+        dynamic_predictions.extend(best_pattern_values)
+        current_values = dynamic_predictions[-5:]  # Mise à jour avec les 5 dernières valeurs
+
+    future_timestamps = [df.index[-1] + timedelta(minutes=15 * i) for i in range(1, len(dynamic_predictions) + 1)]
+    dynamic_curve = pd.DataFrame({"timestamp": future_timestamps, "price": dynamic_predictions})
     return dynamic_curve
 
 # Configuration des dates
 end_time = datetime.now()
-start_time = end_time - timedelta(hours=48)
+start_time = end_time - timedelta(days=30)
 
-# Liste des cryptos avec leurs IDs corrects sur CoinCap
+# Cryptos à suivre
 coins = {
-    "Bitcoin": "bitcoin",
-    "Ripple": "xrp",
-    "Ethereum": "ethereum",
-    "Tether": "tether",
-    "Stellar": "stellar"
+    'bitcoin': 'bitcoin',
+    'ethereum': 'ethereum',
+    'litecoin': 'litecoin'
 }
 
-# Récupération des prix
-crypto_prices = get_crypto_prices(coins, start_time, end_time)
-
-# Affichage des graphiques
-st.title("Analyse et Prédictions des Cryptos avec Patterns")
-for coin, price_data in crypto_prices.items():
-    if price_data:
-        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)
-
-        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 la prédiction initiale (en jaune)
-        best_pattern_df = patterns[best_pattern]
-        ax.plot(
-            best_pattern_df["timestamp"],
-            best_pattern_df["price"],
-            label=f"Prédiction initiale ({best_pattern})",
-            linestyle="dashed",
-            color="yellow"
-        )
-
-        # Génère la courbe dynamique (en vert) basée sur les patterns historiques
-        dynamic_curve = generate_dynamic_curve(df, best_pattern_df["price"].values)
-        future_timestamps = pd.date_range(df["timestamp"].iloc[-1], periods=(24 * 60 // 15) + 1, freq="15T")
-        ax.plot(future_timestamps, dynamic_curve, label="Prédiction dynamique (basée sur historique)", linestyle="dashed", color="green")
-
-        ax.set_title(f"{coin} - Prix (48h réels + 24h prévu avec {best_pattern})")
-        ax.set_xlabel("Temps")
-        ax.set_ylabel("Prix (USD)")
-        ax.legend()
-        st.pyplot(fig)
-
-        # Texte explicatif du pattern choisi
-        explanation = {
-            "Trend": "Ce pattern indique que le prix continue sur la tendance actuelle, il suit la direction des prix précédents.",
-            "Reversal": "Ce pattern suggère que le prix pourrait inverser la tendance actuelle, en suivant la direction opposée.",
-            "SMA": "Le prix pourrait se stabiliser autour de la moyenne mobile simple (SMA), une approximation de la tendance générale.",
-            "EMA": "Ce pattern suit la moyenne mobile exponentielle (EMA), qui réagit plus rapidement aux changements de prix.",
-            "Cycle": "Le pattern de cycle suppose une oscillation autour d'un point central, représentant des mouvements de prix cycliques.",
-            "Rebound": "Le prix pourrait rebondir après avoir montré des signes de ralentissement, suivant une courbe d'amortissement.",
-            "Plateau": "Ce pattern suggère que le prix restera relativement stable et horizontal, sans mouvements majeurs.",
-            "Breakout": "Le breakout indique une rupture de la tendance actuelle, avec une direction plus forte dans une des deux directions.",
-            "Recovery": "Le pattern de récupération suggère que le prix pourrait revenir à sa moyenne historique après une variation importante.",
-            "Acceleration": "L'accélération suggère un mouvement rapide des prix, souvent après une période de stagnation ou de consolidation."
-        }
+# Récupérer les prix
+prices = get_crypto_prices(coins, start_time, end_time)
+
+# Prédiction des tendances avec des patterns
+pattern_dfs = {}
+for coin, data in prices.items():
+    pattern_dfs[coin] = predict_patterns(data)
 
-        # Afficher l'explication sous le graphique
-        st.write(f"### Explication du pattern ({best_pattern}):")
-        st.write(explanation[best_pattern])
+# Calculer les prédictions dynamiques
+dynamic_curves = {}
+for coin, pattern_df in pattern_dfs.items():
+    dynamic_curves[coin] = predict_dynamic_curve(prices[coin], pattern_df)
 
-    else:
-        st.warning(f"Aucune donnée disponible pour {coin}")
+# Affichage des courbes dynamiques
+for coin, dynamic_curve in dynamic_curves.items():
+    st.write(f"Prédiction dynamique pour {coin.capitalize()}:")
+    st.line_chart(dynamic_curve.set_index('timestamp')['price'])