Update app.py

app.py

@@ -1,12 +1,12 @@
+import streamlit as st
 import yfinance as yf
 import pandas as pd
-import numpy as np
+import matplotlib.pyplot as plt
+from statsmodels.tsa.arima.model import ARIMA
 from sklearn.preprocessing import MinMaxScaler
-from tensorflow import keras
 from tensorflow.keras.models import Sequential
 from tensorflow.keras.layers import Dense, LSTM, GRU
-from statsmodels.tsa.arima.model import ARIMA
-from kerastuner.tuners import RandomSearch
+import numpy as np
 
 # Function to load stock data using yfinance
 def get_stock_data(symbol, start_date, end_date):
@@ -20,128 +20,104 @@ def prepare_data(data):
     return scaled_data, scaler
 
 # Function to create LSTM model
-def create_lstm_model(input_shape, hp):
+def create_lstm_model(input_shape):
     model = Sequential()
-    model.add(LSTM(units=hp.Int('units', min_value=32, max_value=512, step=32),
-                   return_sequences=True, input_shape=input_shape))
-    model.add(LSTM(units=hp.Int('units', min_value=32, max_value=512, step=32),
-                   return_sequences=True))
-    model.add(LSTM(units=hp.Int('units', min_value=32, max_value=512, step=32)))
+    model.add(LSTM(units=50, return_sequences=True, input_shape=input_shape))
+    model.add(LSTM(units=50, return_sequences=True))
+    model.add(LSTM(units=50))
     model.add(Dense(units=1))
     model.compile(optimizer='adam', loss='mean_squared_error')
     return model
 
 # Function to create GRU model
-def create_gru_model(input_shape, hp):
+def create_gru_model(input_shape):
     model = Sequential()
-    model.add(GRU(units=hp.Int('units', min_value=32, max_value=512, step=32),
-                   return_sequences=True, input_shape=input_shape))
-    model.add(GRU(units=hp.Int('units', min_value=32, max_value=512, step=32),
-                   return_sequences=True))
-    model.add(GRU(units=hp.Int('units', min_value=32, max_value=512, step=32)))
+    model.add(GRU(units=50, return_sequences=True, input_shape=input_shape))
+    model.add(GRU(units=50, return_sequences=True))
+    model.add(GRU(units=50))
     model.add(Dense(units=1))
     model.compile(optimizer='adam', loss='mean_squared_error')
     return model
 
-# Function to create ARIMA model
-def create_arima_model(data, hp):
-    # The order parameter is the hyperparameter to be tuned
-    p = hp.Int('p', min_value=1, max_value=5, step=1)
-    d = hp.Int('d', min_value=0, max_value=1, step=1)
-    q = hp.Int('q', min_value=1, max_value=5, step=1)
-    
-    model = ARIMA(data, order=(p, d, q))
-    return model
+# Function to fit LSTM/GRU model and make predictions
+def lstm_gru_forecast(data, model_type, steps):
+    scaled_data, scaler = prepare_data(data)
+    input_data = scaled_data.reshape(-1, 1)
 
-# Function to create Keras Tuner RandomSearch
-def create_tuner(model_builder, objective):
-    return RandomSearch(model_builder,
-                        objective=objective,
-                        max_epochs=10,
-                        factor=3,
-                        directory='keras_tuner_logs',
-                        project_name='stock_price_forecasting')
-
-# Function to fit ARIMA model using Keras Tuner
-def tune_arima_model(data, tuner, hp):
-    # The ARIMA model is fit differently than neural networks
-    model = tuner.oracle.get_best_trials(1)[0].hyperparameters.values
-    order = (model['p'], model['d'], model['q'])
-
-    # Fit ARIMA model
-    arima_model = ARIMA(data, order=order)
-    arima_model_fit = arima_model.fit()
+    # Split data into training and testing sets
+    train_size = int(len(input_data) * 0.80)
+    train_data, test_data = input_data[0:train_size, :], input_data[train_size:len(input_data), :]
 
-    # Make predictions
-    forecast_steps = tuner.oracle.get_best_trials(1)[0].metrics.values['steps']
-    arima_forecast = arima_model_fit.get_forecast(steps=forecast_steps)
-    arima_predictions = arima_forecast.predicted_mean
+    x_train, y_train = [], []
+    for i in range(60, len(train_data)):
+        x_train.append(train_data[i - 60:i, 0])
+        y_train.append(train_data[i, 0])
+
+    x_train, y_train = np.array(x_train), np.array(y_train)
+    x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
+
+    # Create and fit the model
+    input_shape = (x_train.shape[1], 1)
+    if model_type == 'lstm':
+        model = create_lstm_model(input_shape)
+    elif model_type == 'gru':
+        model = create_gru_model(input_shape)
 
-    return arima_predictions
+    model.fit(x_train, y_train, epochs=25, batch_size=32)
 
-# Function to create ensemble forecast by averaging predictions
+    # Make predictions
+    inputs = input_data[len(input_data) - len(test_data) - 60:]
+    inputs = inputs.reshape(-1, 1)
+    x_test = []
+    for i in range(60, len(inputs)):
+        x_test.append(inputs[i - 60:i, 0])
+    x_test = np.array(x_test)
+
+    x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1))
+    predicted_prices = model.predict(x_test)
+    predicted_prices = scaler.inverse_transform(predicted_prices)
+
+    # Create an index for the forecasted values
+    forecast_index = pd.date_range(start=data.index[-1], periods=steps + 1, freq=data.index.freq)
+    
+    return pd.Series(predicted_prices.flatten(), index=forecast_index[1:])
+
+# Function to create an ensemble forecast by averaging predictions
 def ensemble_forecast(predictions_list):
     return pd.DataFrame(predictions_list).mean(axis=0)
 
+# Streamlit App
+st.title("Stock Price Forecasting App")
+
 # Load stock data
 symbol = 'AAPL'  # Replace with the desired stock symbol
 start_date = '2021-01-01'
 end_date = '2022-01-01'
 stock_prices = get_stock_data(symbol, start_date, end_date)
 
-# Define input shape for LSTM
-input_shape = (60, 1)
-
-# Objective for Keras Tuner
-def objective(hp):
-    lstm_model = create_lstm_model(input_shape, hp)
-    lstm_model.fit(x_train, y_train, epochs=10, validation_split=0.2)
-    loss = lstm_model.evaluate(x_test, y_test)
-    return loss
-
-# Create Keras Tuner for LSTM
-tuner_lstm = create_tuner(create_lstm_model, objective)
-
-# Split data into training and testing sets for LSTM
-scaled_data, scaler = prepare_data(stock_prices)
-input_data = scaled_data.reshape(-1, 1)
-
-train_size = int(len(input_data) * 0.80)
-train_data, test_data = input_data[0:train_size, :], input_data[train_size:len(input_data), :]
-
-x_train, y_train = [], []
-for i in range(60, len(train_data)):
-    x_train.append(train_data[i - 60:i, 0])
-    y_train.append(train_data[i, 0])
-
-x_train, y_train = np.array(x_train), np.array(y_train)
-x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
-
-x_test, y_test = [], []
-for i in range(60, len(test_data)):
-    x_test.append(test_data[i - 60:i, 0])
-    y_test.append(test_data[i, 0])
-
-x_test, y_test = np.array(x_test), np.array(y_test)
-x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1))
+# ARIMA parameters
+arima_order = (3, 0, 0)  # Example: AR component (p) is set to 3, differencing (d) is 0, MA component (q) is 0
+arima_forecast_steps = 30  # Number of steps to forecast (adjust based on your preference)
 
-# Tune LSTM model
-tuner_lstm.search(x_train, y_train, epochs=10, validation_split=0.2)
+# LSTM and GRU parameters
+lstm_gru_forecast_steps = 30  # Number of steps to forecast (adjust based on your preference)
 
-# Retrieve the best LSTM model
-best_lstm_model = tuner_lstm.get_best_models(num_models=1)[0]
+# ARIMA Forecast
+arima_predictions = arima_forecast(stock_prices, arima_order, arima_forecast_steps)
 
-# Make LSTM predictions
-lstm_predictions = best_lstm_model.predict(x_test)
-lstm_predictions = scaler.inverse_transform(lstm_predictions)
+# LSTM Forecast
+lstm_predictions = lstm_gru_forecast(stock_prices, 'lstm', lstm_gru_forecast_steps)
 
-# Tune ARIMA model
-tuner_arima = create_tuner(create_arima_model, 'val_loss')
-tuner_arima.search(stock_prices, epochs=10, validation_split=0.2)
+# GRU Forecast
+gru_predictions = lstm_gru_forecast(stock_prices, 'gru', lstm_gru_forecast_steps)
 
-# Retrieve the best ARIMA model
-arima_predictions = tune_arima_model(stock_prices, tuner_arima, x_test, y_test)
+# Ensemble Forecast (Averaging)
+ensemble_predictions = ensemble_forecast([arima_predictions, lstm_predictions, gru_predictions])
 
-# Tune GRU model (similar to LSTM tuning)
-tuner_gru = create_tuner(create_gru_model, objective)
-tuner
+# Plotting
+st.write("### Historical Stock Prices and Forecasts")
+st.line_chart(stock_prices)
+st.line_chart(arima_predictions)
+st.line_chart(lstm_predictions)
+st.line_chart(gru_predictions)
+st.line_chart(ensemble_predictions)