Update app.py

app.py

@@ -1,97 +1,111 @@
-import yfinance as yf
 import numpy as np
 import pandas as pd
-import tensorflow as tf
+import yfinance as yf
 from sklearn.preprocessing import MinMaxScaler
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import LSTM, Dense, Dropout
 import gradio as gr
 import matplotlib.pyplot as plt
+from datetime import datetime, timedelta
 
-# Define stock tickers for the dropdown
-tickers = ['AAPL', 'MSFT', 'GOOGL', 'TSLA', 'AMZN', 'FB', 'NFLX', 'NVDA', 'INTC', 'IBM']
+# Fetch historical stock data
+def fetch_data(ticker, start_date, end_date):
+    data = yf.download(ticker, start=start_date, end=end_date)
+    return data
 
-# 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
+# Preprocess data
+def preprocess_data(data):
+    # Use only the 'Close' prices for prediction
+    data = data[['Close']]
     scaler = MinMaxScaler(feature_range=(0, 1))
-    scaled_data = scaler.fit_transform(df_close)
+    scaled_data = scaler.fit_transform(data)
+
+    # Prepare training data
+    x_train, y_train = [], []
+    for i in range(60, len(scaled_data)):
+        x_train.append(scaled_data[i-60:i, 0])
+        y_train.append(scaled_data[i, 0])
+    x_train, y_train = np.array(x_train), np.array(y_train)
 
-    # 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 for LSTM [samples, time steps, features]
+    x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
     
-    X_train, y_train = create_dataset(scaled_data)
+    return x_train, y_train, scaler
 
-    # Reshape the data for LSTM [samples, time steps, features]
-    X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
+# Build the LSTM model
+def build_model():
+    model = Sequential()
+    model.add(LSTM(units=50, return_sequences=True, input_shape=(60, 1)))
+    model.add(Dropout(0.2))
+    model.add(LSTM(units=50, return_sequences=False))
+    model.add(Dropout(0.2))
+    model.add(Dense(units=25))
+    model.add(Dense(units=1))  # Output layer for price prediction
+    model.compile(optimizer='adam', loss='mean_squared_error')
+    return model
+
+# Train the model
+def train_model(ticker, start_date, end_date):
+    data = fetch_data(ticker, start_date, end_date)
+    x_train, y_train, scaler = preprocess_data(data)
     
-    # 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)
-    ])
+    model = build_model()
+    model.fit(x_train, y_train, batch_size=1, epochs=1)
     
-    # Compile the model
-    lstm_model.compile(optimizer='adam', loss='mean_squared_error')
+    return model, scaler, data
+
+# Predict the stock price for tomorrow
+def predict_next_day(model, scaler, data):
+    last_60_days = data['Close'][-60:].values
+    last_60_days_scaled = scaler.transform(last_60_days.reshape(-1, 1))
     
-    # Train the model
-    lstm_model.fit(X_train, y_train, batch_size=1, epochs=1)
+    x_test = []
+    x_test.append(last_60_days_scaled)
+    x_test = np.array(x_test)
+    x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1))
 
-    # Predict on the same data (just for demonstration)
-    predictions = lstm_model.predict(X_train)
-    predictions = scaler.inverse_transform(predictions)  # Convert back to original scale
+    predicted_price = model.predict(x_test)
+    predicted_price = scaler.inverse_transform(predicted_price)  # Convert back to original scale
+    return predicted_price[0][0]
 
-    # Create a plot to show predictions
-    plt.figure(figsize=(10, 5))
-    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('Days')
-    plt.ylabel('Stock Price')
+# Create a graph of historical and predicted prices
+def create_graph(data, predicted_price):
+    plt.figure(figsize=(14, 5))
+    plt.plot(data.index, data['Close'], label='Historical Prices', color='blue')
+    tomorrow = datetime.now() + timedelta(days=1)
+    plt.scatter(tomorrow, predicted_price, label='Predicted Price for Tomorrow', color='red')
+    plt.title('Stock Price Prediction')
+    plt.xlabel('Date')
+    plt.ylabel('Price')
     plt.legend()
-    
-    # Save the plot to display in Gradio app
-    plt.savefig('stock_prediction_plot.png')
+    plt.grid()
+    plt.xticks(rotation=45)
+    plt.tight_layout()
+    plt.savefig('/mnt/data/stock_prediction_graph.png')  # Save the graph
+    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'
+# Gradio Interface
+def stock_prediction_app(ticker, start_date, end_date):
+    model, scaler, data = train_model(ticker, start_date, end_date)
+    predicted_price = predict_next_day(model, scaler, data)
+    create_graph(data, predicted_price)
+    
+    return f'The predicted stock price for tomorrow is ${predicted_price:.2f}', '/mnt/data/stock_prediction_graph.png'
 
-# Create the Gradio UI for the app
-app = gr.Blocks()
+# Stock tickers for dropdown
+stock_tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'FB', 'TSLA', 'NFLX', 'NVDA', 'INTC', 'AMD']
 
-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_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])
+# Create Gradio Interface
+ticker_input = gr.Dropdown(choices=stock_tickers, label="Select Stock Ticker")
+start_date_input = gr.Date(label="Start Date")
+end_date_input = gr.Date(label="End Date")
 
-# Launch the Gradio app
-app.launch()
+iface = gr.Interface(
+    fn=stock_prediction_app,
+    inputs=[ticker_input, start_date_input, end_date_input],
+    outputs=["text", "image"],
+    title="Stock Price Prediction App",
+    description="Predict tomorrow's stock price based on historical data.",
+)
 
+iface.launch()