Update app.py

app.py

@@ -4,14 +4,15 @@ import numpy as np
 from datetime import datetime, timedelta
 from plotly.subplots import make_subplots
 import plotly.graph_objects as go
-from prophet import Prophet
+from prophet.serialize import model_from_json
 from statsmodels.tsa.arima.model import ARIMA
 from statsmodels.tsa.stattools import adfuller
 from sklearn.preprocessing import MinMaxScaler
 from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
 import tensorflow as tf
-from tensorflow.keras.models import Sequential
+from tensorflow.keras.models import Sequential, load_model
 from tensorflow.keras.layers import LSTM, Dense, Dropout
+import pickle
 import warnings
 warnings.filterwarnings('ignore')
 
@@ -66,85 +67,52 @@ def test_stationarity(timeseries):
 # MODEL 1: ARIMA
 # ============================================================================
 
-def train_arima_model(data, order=(5,1,0)):
-    """Train ARIMA model"""
+def load_arima_model():
+    """Load pre-trained ARIMA model"""
     try:
-        print(f"Training ARIMA{order}...")
-        model = ARIMA(data, order=order)
-        fitted_model = model.fit()
-        print("ARIMA trained successfully")
-        return fitted_model
+        with open('models/arima_model.pkl', 'rb') as f:
+            model = pickle.load(f)
+        print("ARIMA model loaded successfully")
+        return model
     except Exception as e:
-        print(f"ARIMA Error: {e}")
+        print(f"ARIMA Load Error: {e}")
         return None
 
 # ============================================================================
 # MODEL 2: PROPHET
 # ============================================================================
 
-def train_prophet_model(df):
-    """Train Prophet model"""
+def load_prophet_model():
+    """Load pre-trained Prophet model"""
     try:
-        print("Training Prophet...")
-        prophet_df = pd.DataFrame({
-            'ds': df['Date'],
-            'y': df['Close'].values
-        })
-        
-        model = Prophet(
-            daily_seasonality=True,
-            yearly_seasonality=True,
-            weekly_seasonality=True,
-            changepoint_prior_scale=0.05,
-            seasonality_prior_scale=10.0
-        )
-        model.fit(prophet_df)
-        print("Prophet trained successfully")
+        # Load the model from JSON
+        with open('models/prophet_model.json', 'r') as f:
+            model = model_from_json(f.read())
+        print("Prophet model loaded successfully")
         return model
     except Exception as e:
-        print(f"Prophet Error: {e}")
+        print(f"Prophet Load Error: {e}")
         return None
 
 # ============================================================================
 # MODEL 3: LSTM
 # ============================================================================
 
-def create_lstm_dataset(data, look_back=60):
-    """Create sequences for LSTM"""
-    X, y = [], []
-    for i in range(look_back, len(data)):
-        X.append(data[i-look_back:i, 0])
-        y.append(data[i, 0])
-    return np.array(X), np.array(y)
-
-def train_lstm_model(data, look_back=60, epochs=50):
-    """Train LSTM model"""
+def load_lstm_model():
+    """Load pre-trained LSTM model and scaler"""
     try:
-        print("Training LSTM...")
-        
-        scaler = MinMaxScaler(feature_range=(0, 1))
-        scaled_data = scaler.fit_transform(data.reshape(-1, 1))
-        
-        X, y = create_lstm_dataset(scaled_data, look_back)
-        X = X.reshape((X.shape[0], X.shape[1], 1))
-        
-        model = Sequential([
-            LSTM(50, return_sequences=True, input_shape=(look_back, 1)),
-            Dropout(0.2),
-            LSTM(50, return_sequences=False),
-            Dropout(0.2),
-            Dense(25, activation='relu'),
-            Dense(1)
-        ])
+        # Load the model
+        lstm_model = load_model('models/lstm_model.h5')
         
-        model.compile(optimizer='adam', loss='mean_squared_error')
-        model.fit(X, y, batch_size=32, epochs=epochs, verbose=0)
+        # Load the scaler
+        with open('models/lstm_scaler.pkl', 'rb') as f:
+            scaler = pickle.load(f)
         
-        print("LSTM trained successfully")
-        return model, scaler, look_back
+        print("LSTM model and scaler loaded successfully")
+        return lstm_model, scaler
     except Exception as e:
-        print(f"LSTM Error: {e}")
-        return None, None, None
+        print(f"LSTM Load Error: {e}")
+        return None, None
 
 # ============================================================================
 # EDA FUNCTION
@@ -271,7 +239,7 @@ def rolling_window_evaluation(df, test_size=90):
     }
     
     # ARIMA
-    arima_model = train_arima_model(train_data['Close'].values)
+    arima_model = load_arima_model()
     if arima_model:
         arima_forecast = arima_model.forecast(steps=test_size)
         results['ARIMA']['predictions'] = arima_forecast
@@ -280,7 +248,7 @@ def rolling_window_evaluation(df, test_size=90):
         print(f"ARIMA - RMSE: {rmse:.2f}, MAE: {mae:.2f}, MAPE: {mape:.2f}%, R2: {r2:.4f}")
     
     # Prophet
-    prophet_model = train_prophet_model(train_data)
+    prophet_model = load_prophet_model()
     if prophet_model:
         future = prophet_model.make_future_dataframe(periods=test_size)
         forecast = prophet_model.predict(future)
@@ -291,15 +259,15 @@ def rolling_window_evaluation(df, test_size=90):
         print(f"Prophet - RMSE: {rmse:.2f}, MAE: {mae:.2f}, MAPE: {mape:.2f}%, R2: {r2:.4f}")
     
     # LSTM
-    lstm_model, scaler, look_back = train_lstm_model(train_data['Close'].values, epochs=50)
+    lstm_model, scaler = load_lstm_model()
     if lstm_model and scaler:
         all_data = df['Close'].values
-        test_inputs = all_data[len(train_data) - look_back:]
+        test_inputs = all_data[len(train_data) - 60:]  # Using look_back=60 as in original code
         test_inputs = scaler.transform(test_inputs.reshape(-1, 1))
         
         X_test = []
-        for i in range(look_back, len(test_inputs)):
-            X_test.append(test_inputs[i-look_back:i, 0])
+        for i in range(60, len(test_inputs)):
+            X_test.append(test_inputs[i-60:i, 0])
         X_test = np.array(X_test)
         X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))
         
@@ -329,26 +297,26 @@ def predict_future(df, days_to_predict=30):
     predictions = {}
     
     # ARIMA
-    arima_model = train_arima_model(full_data)
+    arima_model = load_arima_model()
     if arima_model:
         arima_forecast = arima_model.forecast(steps=days_to_predict)
         predictions['ARIMA'] = arima_forecast
     
     # Prophet
-    prophet_model = train_prophet_model(df)
+    prophet_model = load_prophet_model()
     if prophet_model:
         future = prophet_model.make_future_dataframe(periods=days_to_predict)
         forecast = prophet_model.predict(future)
         predictions['Prophet'] = forecast['yhat'].iloc[-days_to_predict:].values
     
     # LSTM
-    lstm_model, scaler, look_back = train_lstm_model(full_data, epochs=50)
+    lstm_model, scaler = load_lstm_model()
     if lstm_model and scaler:
-        last_sequence = scaler.transform(full_data[-look_back:].reshape(-1, 1))
+        last_sequence = scaler.transform(full_data[-60:].reshape(-1, 1))  # Using look_back=60
         lstm_predictions = []
         
         for _ in range(days_to_predict):
-            X_test = last_sequence.reshape((1, look_back, 1))
+            X_test = last_sequence.reshape((1, 60, 1))
             pred = lstm_model.predict(X_test, verbose=0)
             lstm_predictions.append(pred[0, 0])
             last_sequence = np.append(last_sequence[1:], pred).reshape(-1, 1)