Update app.py

app.py

@@ -1,100 +1,96 @@
-import gradio as gr
+import yfinance as yf
 import numpy as np
 import pandas as pd
-import yfinance as yf
-import matplotlib.pyplot as plt
+import tensorflow as tf
 from sklearn.preprocessing import MinMaxScaler
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.layers import LSTM, Dense
+import gradio as gr
+import matplotlib.pyplot as plt
 
-# Define the available stock tickers
+# Define stock tickers for the dropdown
 tickers = ['AAPL', 'MSFT', 'GOOGL', 'TSLA', 'AMZN', 'FB', 'NFLX', 'NVDA', 'INTC', 'IBM']
 
-def train_model(data):
-    # Prepare data for LSTM
-    scaler = MinMaxScaler(feature_range=(0, 1))
-    scaled_data = scaler.fit_transform(data['Close'].values.reshape(-1, 1))
+# Function to fetch stock data and make predictions
+def stock_prediction_app(ticker, start_date, end_date):
+    # Fetch historical stock data from Yahoo Finance
+    stock_data = yf.download(ticker, start=start_date, end=end_date)
     
-    # Create training data
-    train_data = []
-    for i in range(60, len(scaled_data)):
-        train_data.append(scaled_data[i-60:i, 0])
+    # Check if data is fetched correctly
+    if stock_data.empty:
+        return "No data available for the selected date range.", None
+    
+    # Prepare the data for LSTM model
+    df_close = stock_data[['Close']]  # Use only the 'Close' column for prediction
+    scaler = MinMaxScaler(feature_range=(0, 1))
+    scaled_data = scaler.fit_transform(df_close)
 
-    train_data = np.array(train_data)
+    # Create datasets for training the LSTM model
+    def create_dataset(data, time_step=60):
+        X_train, y_train = [], []
+        for i in range(len(data)-time_step-1):
+            X_train.append(data[i:(i+time_step), 0])
+            y_train.append(data[i + time_step, 0])
+        return np.array(X_train), np.array(y_train)
     
-    # Reshape data for LSTM
-    X_train = train_data.reshape((train_data.shape[0], train_data.shape[1], 1))
+    X_train, y_train = create_dataset(scaled_data)
 
+    # Reshape the data for LSTM [samples, time steps, features]
+    X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
+    
     # Define LSTM model
-    model = Sequential()
-    model.add(LSTM(50, return_sequences=True, input_shape=(X_train.shape[1], 1)))
-    model.add(LSTM(50, return_sequences=False))
-    model.add(Dense(25))
-    model.add(Dense(1))
-
-    # Compile model
-    model.compile(optimizer='adam', loss='mean_squared_error')
-    model.fit(X_train, np.array(data['Close'][60:]), batch_size=1, epochs=1)
-
-    return model, scaler
-
-def stock_prediction_app(ticker, start_date, end_date):
-    # Fetch stock data
-    data = yf.download(ticker, start=start_date, end=end_date)
-    if data.empty:
-        return "No data found for the selected dates.", None
+    lstm_model = tf.keras.Sequential([
+        tf.keras.layers.LSTM(50, return_sequences=True, input_shape=(60, 1)),
+        tf.keras.layers.LSTM(50, return_sequences=False),
+        tf.keras.layers.Dense(25),
+        tf.keras.layers.Dense(1)
+    ])
     
-    # Train the model
-    model, scaler = train_model(data)
-
-    # Predict future prices
-    last_60_days = data['Close'][-60:].values.reshape(-1, 1)
-    last_60_days_scaled = scaler.transform(last_60_days)
-    X_test = []
-    X_test.append(last_60_days_scaled)
-    X_test = np.array(X_test).reshape((1, X_test.shape[1], 1))
+    # Compile the model
+    lstm_model.compile(optimizer='adam', loss='mean_squared_error')
     
-    # Predicting the price
-    predicted_price = model.predict(X_test)
-    predicted_price = scaler.inverse_transform(predicted_price)
+    # Train the model
+    lstm_model.fit(X_train, y_train, batch_size=1, epochs=1)
 
-    # Calculate additional information
-    current_price = data['Close'].iloc[-1]
-    highest_price = data['Close'].max()
-    lowest_price = data['Close'].min()
-    percentage_change = ((predicted_price[0][0] - current_price) / current_price) * 100
+    # Predict on the same data (just for demonstration)
+    predictions = lstm_model.predict(X_train)
+    predictions = scaler.inverse_transform(predictions)  # Convert back to original scale
 
-    # Plotting historical and predicted prices
+    # Create a plot to show predictions
     plt.figure(figsize=(10, 5))
-    plt.plot(data['Close'], label='Historical Prices')
-    plt.axhline(y=predicted_price[0][0], color='r', linestyle='--', label='Predicted Price')
+    plt.plot(df_close.values, label='Actual Stock Price')
+    plt.plot(predictions, label='Predicted Stock Price')
     plt.title(f'{ticker} Stock Price Prediction')
-    plt.xlabel('Date')
-    plt.ylabel('Price')
+    plt.xlabel('Days')
+    plt.ylabel('Stock Price')
     plt.legend()
-    plt.grid()
     
-    # Save the plot
-    plt.savefig("predicted_stock_price.png")
-    plt.close()
+    # Save the plot to display in Gradio app
+    plt.savefig('stock_prediction_plot.png')
 
-    return f"Predicted Price: ${predicted_price[0][0]:.2f}\nCurrent Price: ${current_price:.2f}\nPercentage Change: {percentage_change:.2f}%\nHighest Price: ${highest_price:.2f}\nLowest Price: ${lowest_price:.2f}", "predicted_stock_price.png"
+    # Return a message and the path to the saved plot
+    return f"Prediction complete for {ticker} from {start_date} to {end_date}", 'stock_prediction_plot.png'
 
-# Gradio UI
+# Create the Gradio UI for the app
 app = gr.Blocks()
 
 with app:
     gr.Markdown("# Stock Buy/Sell Prediction App")
     
+    # Dropdown for stock tickers
     ticker = gr.Dropdown(tickers, label="Select Stock Ticker")
+    
+    # Textboxes for manual date input
     start_date = gr.Textbox(label="Start Date (YYYY-MM-DD)")
     end_date = gr.Textbox(label="End Date (YYYY-MM-DD)")
     
+    # Button to trigger the prediction
     predict_button = gr.Button("Predict")
     
-    output_text = gr.Textbox(label="Prediction Result", interactive=False)
+    # Output fields for text and image
+    output_text = gr.Textbox(label="Prediction Result")
     output_image = gr.Image(label="Stock Price Graph")
     
+    # Set up button click event to run the prediction function
     predict_button.click(fn=stock_prediction_app, inputs=[ticker, start_date, end_date], outputs=[output_text, output_image])
 
+# Launch the Gradio app
 app.launch()