Spaces:
Build error
Build error
File size: 7,699 Bytes
3308842 98e569e 3308842 0624205 3308842 0624205 3308842 e146993 3308842 e146993 3308842 e146993 3308842 0624205 3308842 0624205 3308842 0624205 3308842 0624205 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 | import streamlit as st
import requests
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from datetime import datetime, timedelta
from sklearn.metrics import mean_squared_error
# Fonction pour récupérer les prix historiques
def get_crypto_prices(coins, start_time, end_time, interval='h1'):
prices = {}
for coin, coin_id in coins.items():
url = f'https://api.coincap.io/v2/assets/{coin_id}/history'
params = {
'interval': interval,
'start': int(start_time.timestamp() * 1000),
'end': int(end_time.timestamp() * 1000)
}
response = requests.get(url, params=params)
if response.status_code == 200:
data = response.json().get('data', [])
prices[coin] = [[int(item['time']), float(item['priceUsd'])] for item in data]
if data:
prices[coin].append([int(end_time.timestamp() * 1000), float(data[-1]['priceUsd'])])
else:
st.error(f"Erreur lors de la récupération des prix pour {coin}: {response.status_code}")
st.write(response.text) # Debug pour afficher l'erreur complète
return prices
# Fonction pour prédire les tendances basées sur les patterns
def predict_patterns(data, future_hours=24):
df = pd.DataFrame(data, columns=["timestamp", "price"])
df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
df.set_index("timestamp", inplace=True)
last_timestamp = df.index[-1]
future_timestamps = [last_timestamp + timedelta(hours=i) for i in range(1, future_hours + 1)]
last_price = df["price"].iloc[-1]
trend = (df["price"].iloc[-1] - df["price"].iloc[0]) / len(df)
sma = df["price"].rolling(window=10).mean().iloc[-1]
ema = df["price"].ewm(span=10, adjust=False).mean().iloc[-1]
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()
}
return pattern_dfs
# Fonction pour identifier le pattern le plus ressemblant
def identify_best_pattern(df, patterns):
mse_scores = {}
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
# Configuration des dates
end_time = datetime.now()
start_time = end_time - timedelta(hours=48)
# Liste des cryptos avec leurs IDs corrects sur CoinCap
coins = {
"Bitcoin": "bitcoin",
"Ripple": "xrp",
"Ethereum": "ethereum",
"Tether": "tether",
"Stellar": "stellar"
}
# 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 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 (48h réels + 24h prévu avec {best_pattern})")
ax.set_xlabel("Date")
ax.set_ylabel("Prix (USD)")
ax.legend()
st.pyplot(fig)
|