Update app.py

app.py

@@ -1,96 +1,100 @@
-import yfinance as yf
+import gradio as gr
 import numpy as np
 import pandas as pd
-import tensorflow as tf
-from sklearn.preprocessing import MinMaxScaler
-import gradio as gr
+import yfinance as yf
 import matplotlib.pyplot as plt
+from sklearn.preprocessing import MinMaxScaler
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import LSTM, Dense
 
-# Define stock tickers for the dropdown
+# Define the available stock tickers
 tickers = ['AAPL', 'MSFT', 'GOOGL', 'TSLA', 'AMZN', 'FB', 'NFLX', 'NVDA', 'INTC', 'IBM']
 
-# 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)
-    
-    # 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
+def train_model(data):
+    # Prepare data for LSTM
     scaler = MinMaxScaler(feature_range=(0, 1))
-    scaled_data = scaler.fit_transform(df_close)
-
-    # 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)
+    scaled_data = scaler.fit_transform(data['Close'].values.reshape(-1, 1))
     
-    X_train, y_train = create_dataset(scaled_data)
+    # Create training data
+    train_data = []
+    for i in range(60, len(scaled_data)):
+        train_data.append(scaled_data[i-60:i, 0])
 
-    # Reshape the data for LSTM [samples, time steps, features]
-    X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
+    train_data = np.array(train_data)
     
+    # Reshape data for LSTM
+    X_train = train_data.reshape((train_data.shape[0], train_data.shape[1], 1))
+
     # Define LSTM model
-    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)
-    ])
-    
-    # Compile the model
-    lstm_model.compile(optimizer='adam', loss='mean_squared_error')
+    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
     
     # Train the model
-    lstm_model.fit(X_train, y_train, batch_size=1, epochs=1)
+    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))
+    
+    # Predicting the price
+    predicted_price = model.predict(X_test)
+    predicted_price = scaler.inverse_transform(predicted_price)
 
-    # Predict on the same data (just for demonstration)
-    predictions = lstm_model.predict(X_train)
-    predictions = scaler.inverse_transform(predictions)  # Convert back to original scale
+    # 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
 
-    # Create a plot to show predictions
+    # Plotting historical and predicted prices
     plt.figure(figsize=(10, 5))
-    plt.plot(df_close.values, label='Actual Stock Price')
-    plt.plot(predictions, label='Predicted Stock Price')
+    plt.plot(data['Close'], label='Historical Prices')
+    plt.axhline(y=predicted_price[0][0], color='r', linestyle='--', label='Predicted Price')
     plt.title(f'{ticker} Stock Price Prediction')
-    plt.xlabel('Days')
-    plt.ylabel('Stock Price')
+    plt.xlabel('Date')
+    plt.ylabel('Price')
     plt.legend()
+    plt.grid()
     
-    # Save the plot to display in Gradio app
-    plt.savefig('stock_prediction_plot.png')
+    # Save the plot
+    plt.savefig("predicted_stock_price.png")
+    plt.close()
 
-    # 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'
+    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"
 
-# Create the Gradio UI for the app
+# Gradio UI
 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 fields for text and image
-    output_text = gr.Textbox(label="Prediction Result")
+    output_text = gr.Textbox(label="Prediction Result", interactive=False)
     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()