Upload 3 files

app.py

@@ -0,0 +1,155 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.metrics import mean_squared_error, mean_absolute_error
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense, LSTM, Dropout
+from datetime import timedelta
+
+# Title and description
+st.title("Stock Price Prediction with LSTM")
+st.write("This application uses LSTM (Long Short-Term Memory) neural networks to predict stock prices.")
+
+# Load the data directly (replace 'AAPL_dataset_copied.csv' with your actual file path)
+data = pd.read_csv('AAPL_dataset_copied.csv')
+
+# Convert 'date' column to datetime and set as index
+data['date'] = pd.to_datetime(data['date'])
+data.set_index('date', inplace=True)
+
+# Select only the 'Close' column
+data = data[['close']]
+
+# Show the first few rows of the dataset
+st.subheader("Dataset Preview")
+st.write(data.head())
+
+# Normalize the data for faster convergence
+scaler = MinMaxScaler(feature_range=(0, 1))
+data['close_scaled'] = scaler.fit_transform(data[['close']])
+
+# Split data into training (70%), validation (15%), and testing (15%) sets
+train_size = int(len(data) * 0.7)
+val_size = int(len(data) * 0.15)
+train_data = data['close_scaled'][:train_size].values.reshape(-1, 1)
+val_data = data['close_scaled'][train_size:train_size + val_size].values.reshape(-1, 1)
+test_data = data['close_scaled'][train_size + val_size:].values.reshape(-1, 1)
+
+# Function to create sequences for LSTM
+def create_sequences(dataset, time_step=60):
+    X, Y = [], []
+    for i in range(len(dataset) - time_step):
+        X.append(dataset[i:(i + time_step), 0])
+        Y.append(dataset[i + time_step, 0])
+    return np.array(X), np.array(Y)
+
+# Define time step (e.g., 60 days)
+time_step = 60
+X_train, y_train = create_sequences(train_data, time_step)
+X_val, y_val = create_sequences(val_data, time_step)
+X_test, y_test = create_sequences(test_data, time_step)
+
+# Reshape input to be [samples, time steps, features] for LSTM
+X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
+X_val = X_val.reshape(X_val.shape[0], X_val.shape[1], 1)
+X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)
+
+# Build the LSTM model with Dropout for regularization
+model = Sequential([
+    LSTM(100, return_sequences=True, input_shape=(X_train.shape[1], 1)),
+    Dropout(0.2),
+    LSTM(50, return_sequences=True),
+    Dropout(0.2),
+    LSTM(50, return_sequences=False),
+    Dropout(0.2),
+    Dense(25),
+    Dense(1)
+])
+
+# Compile the model with Adam optimizer and mean squared error loss
+model.compile(optimizer='adam', loss='mean_squared_error', metrics=['mean_absolute_error'])
+
+# Train the model without EarlyStopping
+st.write("Training the LSTM model...")
+history = model.fit(X_train, y_train, validation_data=(X_val, y_val),
+                    epochs=100, batch_size=64, verbose=1)
+
+# Evaluate on the test data
+test_loss, test_mae = model.evaluate(X_test, y_test, verbose=0)
+
+# Make predictions on the test data
+train_predict = model.predict(X_train)
+val_predict = model.predict(X_val)
+test_predict = model.predict(X_test)
+
+# Inverse transform the predictions and actual values to original scale
+train_predict = scaler.inverse_transform(train_predict)
+val_predict = scaler.inverse_transform(val_predict)
+test_predict = scaler.inverse_transform(test_predict)
+y_train = scaler.inverse_transform([y_train])
+y_val = scaler.inverse_transform([y_val])
+y_test = scaler.inverse_transform([y_test])
+
+# Calculate evaluation metrics
+train_rmse = np.sqrt(mean_squared_error(y_train[0], train_predict[:,0]))
+val_rmse = np.sqrt(mean_squared_error(y_val[0], val_predict[:,0]))
+test_rmse = np.sqrt(mean_squared_error(y_test[0], test_predict[:,0]))
+
+train_mae = mean_absolute_error(y_train[0], train_predict[:,0])
+val_mae = mean_absolute_error(y_val[0], val_predict[:,0])
+test_mae = mean_absolute_error(y_test[0], test_predict[:,0])
+
+# Mean Absolute Percentage Error (MAPE) as accuracy
+mape = np.mean(np.abs((y_test[0] - test_predict[:, 0]) / y_test[0])) * 100
+accuracy = 100 - mape
+
+st.write(f"LSTM Model - Train RMSE: {train_rmse:.2f}, Train MAE: {train_mae:.2f}")
+st.write(f"LSTM Model - Validation RMSE: {val_rmse:.2f}, Validation MAE: {val_mae:.2f}")
+st.write(f"LSTM Model - Test RMSE: {test_rmse:.2f}, Test MAE: {test_mae:.2f}")
+st.write(f"LSTM Model - Test Accuracy: {accuracy:.2f}%")
+
+# Plot the results
+st.subheader("Prediction Results")
+plt.figure(figsize=(14,6))
+plt.plot(data.index[:train_size], scaler.inverse_transform(train_data), label='Training Data')
+plt.plot(data.index[train_size + time_step:train_size + time_step + len(val_predict)], val_predict, label='Validation Predictions')
+plt.plot(data.index[train_size + val_size + time_step:], test_predict, label='Test Predictions')
+plt.plot(data.index[train_size + val_size + time_step:], y_test[0], label='Actual Test Data')
+plt.xlabel('Date')
+plt.ylabel('Stock Price')
+plt.legend(['Training Data', 'Validation Predictions', 'Test Predictions', 'Actual Test Data'], loc='upper left')
+st.pyplot(plt)
+
+# User-defined future prediction days
+num_days_to_predict = st.slider("Select the number of days to predict into the future", min_value=1, max_value=30, value=10)
+
+# Predict future prices for the next 'num_days_to_predict' days
+temp_input = np.array(test_data[-time_step:]).reshape(-1).tolist()
+lst_output = []
+
+for i in range(num_days_to_predict):
+    if len(temp_input) > time_step:
+        x_input = np.array(temp_input[-time_step:])
+        x_input = x_input.reshape((1, time_step, 1))
+        yhat = model.predict(x_input, verbose=0)
+        temp_input.append(yhat[0][0])
+        lst_output.append(yhat[0][0])
+    else:
+        x_input = np.array(temp_input).reshape((1, time_step, 1))
+        yhat = model.predict(x_input, verbose=0)
+        temp_input.append(yhat[0][0])
+        lst_output.append(yhat[0][0])
+
+# Inverse transform future predictions to the original scale
+future_predictions = scaler.inverse_transform(np.array(lst_output).reshape(-1, 1))
+
+# Generate dates for future predictions
+last_date = data.index[-1]
+future_dates = [last_date + timedelta(days=i) for i in range(1, num_days_to_predict + 1)]
+
+# Display future predictions with dates
+st.subheader(f"Future Predictions for the next {num_days_to_predict} days:")
+future_df = pd.DataFrame({'Date': future_dates, 'Predicted Price (LSTM)': future_predictions.flatten()})
+st.write(future_df)

requirements.txt

@@ -0,0 +1,6 @@
+streamlit
+pandas
+numpy
+matplotlib
+scikit-learn
+tensorflow