Create app.py

app.py

@@ -0,0 +1,164 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.metrics import mean_squared_error
+from tensorflow.keras.models import load_model
+from neuralprophet import NeuralProphet
+import pickle
+from datetime import timedelta
+import yfinance as yf
+import tensorflow as tf
+
+tf.get_logger().setLevel('ERROR')  # Pour réduire les logs TensorFlow
+
+# === Fonction pour charger les données boursières ===
+@st.cache_data
+def load_data():
+    # Télécharger les données sur 4 ans pour AMD
+    df = yf.download('AMD', period='4y')
+
+    # Vérifier si les colonnes sont de type MultiIndex
+    if isinstance(df.columns, pd.MultiIndex):
+        # Aplatir les MultiIndex (au cas où les colonnes sont hiérarchiques)
+        df.columns = ['_'.join(col).strip() for col in df.columns.values]
+
+    # Extraire uniquement la colonne 'Close'
+    for col in df.columns:
+        if "Close" in col:
+            df = df[[col]]
+            df.columns = ['Close']
+            break
+    
+    # Réinitialiser l'index pour avoir 'Date' comme colonne
+    df.reset_index(inplace=True)
+    df.rename(columns={'Date': 'ds', 'Close': 'y'}, inplace=True)
+    
+    return df
+
+# === Fonctions de chargement des modèles ===
+@st.cache_resource
+def load_gru_model(path):
+    return load_model(path)
+
+@st.cache_resource
+def load_neural_prophet_model(path):
+    with open(path, 'rb') as f:
+        return pickle.load(f)
+
+# === Prédiction NeuralProphet ===
+def predict_neural_prophet(model, df):
+    future = model.make_future_dataframe(df, periods=21)
+    forecast = model.predict(future)
+    return forecast[['ds', 'yhat1']].tail(21)
+
+# === Préparation des données pour GRU ===
+def prepare_gru_data(series, window_size=20):
+    last_data = series[-window_size:]
+    return np.array(last_data).reshape((1, window_size, 1))
+
+# === Prédiction GRU ===
+def predict_gru(model, df, forecast_days):
+    data = df['y'].values
+    window_size = 20
+    predictions = []
+    input_seq = data[-window_size:]
+
+    for _ in range(forecast_days):
+        X_input = input_seq.reshape((1, window_size, 1))
+        pred = model.predict(X_input)[0][0]
+        predictions.append(pred)
+        input_seq = np.append(input_seq[1:], pred)
+
+    last_date = df['ds'].max()
+    future_dates = []
+    while len(future_dates) < forecast_days:
+        last_date += timedelta(days=1)
+        if last_date.weekday() < 5:  # Exclure les week-ends
+            future_dates.append(last_date)
+
+    return pd.DataFrame({'ds': future_dates, 'yhat': predictions})
+
+# === Calcul du RMSE ===
+def calculate_rmse(y_true, y_pred):
+    return np.sqrt(mean_squared_error(y_true, y_pred))
+
+
+# Chargement des données
+data = load_data()
+# Titre
+st.title("KEYCE INFORMATIQUE ET IA, MASTER II ")
+st.title("CONTROLE CONTINU DE RNN SUR LES MODELES GRU ET NEURAL PROPHET")
+st.subheader("NOM DE L'ETUDIANT: TATSA TCHINDA Colince ")
+# Affichage des données historiques
+st.subheader("Données")
+
+fig, ax = plt.subplots(figsize=(10, 4))
+ax.plot(data['ds'], data['y'], label="Historique", color='black')
+ax.set_xlabel("Date")
+ax.set_ylabel("Prix de clôture")
+ax.set_title("historiques des actions AMD")
+ax.legend()
+st.pyplot(fig)
+
+# Chargement des modèles
+
+gru_model = load_gru_model("model_gru.keras")
+neural_model = load_neural_prophet_model("neuralprophet_model.pkl")
+
+# Prédictions
+st.subheader("🔮 Prédictions sur les 3 prochaines semaines")
+
+np_forecast = predict_neural_prophet(neural_model, data)
+gru_forecast = predict_gru(gru_model, data, 21)
+
+# --- Affichage des graphiques de chaque modèle avec ses prédictions ---
+
+# Graphique pour NeuralProphet
+fig, ax = plt.subplots(figsize=(10, 4))
+ax.plot(data['ds'], data['y'], label="Historique", color='black')
+ax.plot(np_forecast['ds'], np_forecast['yhat1'], label="NeuralProphet", linestyle='--')
+ax.legend()
+ax.set_title("Prédictions NeuralProphet")
+st.pyplot(fig)
+
+# Calcul du RMSE pour NeuralProphet
+true_vals = data['y'].values[-20:]
+np_pred_backtest = neural_model.predict(data.tail(20))[['yhat1']].values.flatten()
+np_rmse = calculate_rmse(true_vals, np_pred_backtest)
+
+# Graphique pour GRU
+fig, ax = plt.subplots(figsize=(10, 4))
+ax.plot(data['ds'], data['y'], label="Historique", color='black')
+ax.plot(gru_forecast['ds'], gru_forecast['yhat'], label="GRU", linestyle='--')
+ax.legend()
+ax.set_title("Prédictions GRU")
+st.pyplot(fig)
+
+# Calcul du RMSE pour GRU
+gru_input = data['y'].values[-40:-20]
+gru_backtest_preds = []
+input_seq = gru_input
+for _ in range(20):
+    X_input = input_seq[-20:].reshape((1, 20, 1))
+    pred = gru_model.predict(X_input)[0][0]
+    gru_backtest_preds.append(pred)
+    input_seq = np.append(input_seq[1:], pred)
+
+gru_rmse = calculate_rmse(true_vals, gru_backtest_preds)
+
+# Résumé des scores RMSE
+st.subheader("Résultats")
+st.table(pd.DataFrame({
+    "Modèle": ["NeuralProphet", "GRU"],
+    "RMSE": [np_rmse, gru_rmse]
+}))
+
+# Afficher et télécharger les prédictions
+final_forecast = pd.merge(np_forecast, gru_forecast, on='ds', how='outer')
+st.subheader("Prédictions Combinées ")
+styled_df = final_forecast.style.format({'yhat1': '{:.2f}', 'yhat': '{:.2f}'})
+st.dataframe(styled_df)
+csv = final_forecast.to_csv(index=False).encode('utf-8')
+st.download_button("Télécharger les prédictions (.csv)", csv, "predictions.csv", "text/csv")
+