Upload 5 files

convertcsv.csv

@@ -0,0 +1,26 @@
+name,symbol,usym,gecko
+Bitcoin,BTC,₿,bitcoin
+Ethereum,ETH,Ξ,ethereum
+Cardano,ADA,₳,cardano
+XRP,XRP,✕,ripple
+Solana,SOL,◎,solana
+Polkadot,DOT,●,polkadot
+Dogecoin,DOGE,Ð,dogecoin
+Dai,DAI,◈,dai
+Litecoin,LTC,Ł,litecoin
+Algorand,ALGO,Ⱥ,algorand
+Bitcoin Cash,BCH,Ƀ,bitcoin-cash
+ECOMI,OMI,Ο,ecomi
+Internet Computer,ICP,∞,internet-computer
+Ethereum Classic,ETC,ξ,ethereum-classic
+Monero,XMR,ɱ,monero
+Tezos,XTZ,ꜩ,tezos
+Iota,MIOTA,ɨ,iota
+EOS,EOS,ε,eos
+Bitcoin SV,BSV,Ɓ,bitcoin-cash-sv
+Maker,MKR,Μ,maker
+Zcash,ZEC,ⓩ,zcash
+Dash,DASH,Đ,dash
+Nano,XNO,Ӿ,nano
+Augur,REP,Ɍ,augur
+Steem,STEEM,ȿ,steem

pages/Predictions.py

@@ -0,0 +1,181 @@
+import pandas as pd
+import numpy as np
+import tensorflow as tf
+import random as rn
+import yfinance as yf
+import streamlit as st
+import datetime as dt
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from sklearn.preprocessing import MinMaxScaler
+
+np.random.seed(1)
+tf.random.set_seed(1)
+rn.seed(1)
+from keras.models import Sequential
+from keras.layers import Dense, Dropout, LSTM
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+from millify import millify
+import pandas_datareader as web
+from cryptocmd import CmcScraper
+from datetime import datetime, timedelta
+
+# import utils
+from utils import *
+import time
+
+
+# récupération des données sur 10 ans 
+start = dt.datetime.today() - dt.timedelta(10 * 365)
+end = dt.datetime.today()
+
+a = start.strftime("%d-%m-%Y")
+b = end.strftime("%d-%m-%Y")
+
+st.write("## Prédiction du cours des cryptomonnaies")
+st.write(f"### Date du jour : {b}")
+
+csv = pd.read_csv("convertcsv.csv")
+symbol = csv["symbol"].tolist()
+
+# creating sidebar
+ticker_input = st.selectbox(
+    "Saisir ou choisir une crypto", symbol, index=symbol.index("BTC")
+)
+
+
+# initialisation du scraper avec les deux dates
+scraper = CmcScraper(ticker_input, a, b)
+# Pandas dataFrame for the same data
+df = scraper.get_dataframe()
+
+
+if ticker_input:
+    # Enregistrement du temps de début
+    start_time = time.time()
+    st.write(f"Génération des prédictions pour : {ticker_input}...")
+    # tri du dataframe par dates croissantes vu que les données sont rendues par ordre décroissant
+    crypto_df = df.sort_values(["Date"], ascending=True, axis=0)
+
+
+    # création du dataframe pour les LSTM
+    crypto_df_lstm = pd.DataFrame(index=range(0, len(crypto_df)), columns=["Date", "Close"])
+    for i in range(0, len(crypto_df)):
+        crypto_df_lstm["Date"][i] = crypto_df["Date"][i]
+        crypto_df_lstm["Close"][i] = crypto_df["Close"][i]
+
+    # on fixe de la date comme index
+    crypto_df_lstm.index = crypto_df_lstm.Date
+    crypto_df_lstm.drop("Date", axis=1, inplace=True)
+    crypto_df_lstm = crypto_df_lstm.sort_index(ascending=True)
+
+
+    dataset = crypto_df_lstm.values
+    # division 70% (train) 20% (test)
+    train_index = int(0.70 * len(dataset))
+
+    # train set
+    train = dataset[:train_index]
+    # test set
+    valid = dataset[train_index:]
+
+    # mise à l'échelle des données
+    scaler = MinMaxScaler(feature_range=(0, 1))
+    scaled_data = scaler.fit_transform(dataset)
+
+    x_train, y_train = [], []
+    window = 30 # un mois 
+    for i in range(window, len(train)):
+        # récupération des données par bloc d'un mois (30 jours)
+        x_train.append(scaled_data[i - window : i, 0])
+        # récupération de la prochaine valeur comme étiquette
+        y_train.append(scaled_data[i, 0])
+    x_train, y_train = np.array(x_train), np.array(y_train)
+
+    # mise sous la forme (nombre d'échantillons, fenêtre de temps, nombre de features)
+    x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
+
+    # construction du réseau LSTM par la méthode fonctionnelle
+    # le réseau n'est pas complexifié pour permettre une exécution rapide
+    model = Sequential()
+    model.add(LSTM(units=100, return_sequences=True, input_shape=(x_train.shape[1], 1)))
+    model.add(Dropout(0.2))
+    model.add(LSTM(units=100))
+    model.add(Dropout(0.2))
+    model.add(Dense(1))
+
+    model.compile(loss="mean_squared_error", optimizer="adam")
+    print("Entrainement du modèle")
+    model.fit(x_train, y_train, epochs=1, batch_size=32,validation_split=0.3)
+    
+
+    # récupération de toutes les valeurs du test set (valid) et des window valeurs avant elles, ce qui explique le -window
+    inputs = crypto_df_lstm[len(crypto_df_lstm) - len(valid) - window :].values
+    inputs = inputs.reshape(-1, 1)
+    inputs = scaler.transform(inputs)
+
+    X_test = []
+    for i in range(window, inputs.shape[0]):
+        X_test.append(inputs[i - window : i, 0])
+    X_test = np.array(X_test)
+
+    # transformation du test set à un format approprié
+    X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))
+    closing_price = model.predict(X_test)
+    closing_price = scaler.inverse_transform(closing_price)
+
+    # for plotting
+    train = crypto_df[:train_index]
+    valid = crypto_df[train_index:]
+    valid["Predictions"] = closing_price
+
+    fig_preds = go.Figure()
+    fig_preds.add_trace(
+        go.Scatter(x=train["Date"], y=train["Close"], name="Train Set")
+    )
+
+    fig_preds.add_trace(
+        go.Scatter(x=valid["Date"], y=valid["Close"], name="Test Set")
+    )
+
+    fig_preds.add_trace(
+        go.Scatter(x=valid["Date"], y=valid["Predictions"], name="Prédictions")
+    )
+
+    fig_preds.update_layout(
+        legend=dict(orientation="h", yanchor="bottom", y=1, xanchor="left", x=0),
+        height=600,
+        title_text=f"Valeurs actuelles VS Valeurs prédites pour {ticker_input}",
+        template="gridon",
+    )
+
+    st.plotly_chart(fig_preds, use_container_width=True)
+
+    # Prédiction au jour suivant
+    real_data = [inputs[len(inputs) - window : len(inputs + 1), 0]]
+    real_data = np.array(real_data)
+    real_data = np.reshape(real_data, (real_data.shape[0], real_data.shape[1], 1))
+
+    prediction = model.predict(real_data)
+    prediction = scaler.inverse_transform(prediction)
+    # calcul des métriques
+    perfs = performances(valid["Close"],valid["Predictions"])
+    end_time = time.time()
+    
+    # Convertir la dernière en objet datetime
+    date_obj = dt.datetime.strptime(b, "%d-%m-%Y")
+
+    # Ajouter un jour
+    nouvelle_date = date_obj + dt.timedelta(days=1)
+
+    # Convertir la nouvelle date en format souhaité
+    nouvelle_date_str = nouvelle_date.strftime("%d-%m-%Y")
+
+    with st.container():
+        col_1, col_2, col_3,col_4 = st.columns(4)
+        col_1.metric(f"Préd. jour **{nouvelle_date_str}** :",f"{str(round(float(prediction), 2))}")
+        col_2.metric(f"R2 Score :", f"{perfs[0]} %")
+        col_3.metric(f"RMSE :",f"{perfs[1]}")
+        col_4.metric(f"Temps mis : ",f"{taken_time(start_time,end_time)}")
+else:
+    st.write("Aucune crypto sélectionnée.")

requirements.txt

@@ -0,0 +1,13 @@
+finta==1.3
+keras==2.9.0
+millify==0.1.1
+numpy==1.21.2
+pandas==1.3.4
+plotly==5.1.0
+scikit_learn==1.1.1
+streamlit==1.10.0
+ta==0.9.0
+tensorflow==2.9.1
+yfinance==0.1.63
+cryptocmd==0.6.1
+pandas_datareader==0.10.0  

utils.py

@@ -0,0 +1,13 @@
+import time
+import numpy as np
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+
+# fonction d'affichage des performances
+def performances(y_pred,y_true):
+  r2 = round(r2_score(y_pred,y_true)*100,2)
+  rmse=round(np.sqrt(np.mean(np.power((np.array(y_pred)-y_true),2))),2)
+  return r2, rmse
+
+
+def taken_time(start_time, end_time):
+  return(f"{round((end_time-start_time)/60,2)} min.")