Create app.py

app.py

@@ -0,0 +1,184 @@
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import tensorflow as tf
+from sklearn.preprocessing import MinMaxScaler
+import matplotlib.pyplot as plt
+import gradio as gr
+
+# Step 1: Fetch stock data
+def fetch_stock_data(ticker, start_date, end_date):
+    """
+    Fetch historical stock data from Yahoo Finance using the yfinance library.
+
+    Args:
+        ticker (str): Stock ticker symbol (e.g., 'AAPL').
+        start_date (str): Start date for fetching stock data (YYYY-MM-DD).
+        end_date (str): End date for fetching stock data (YYYY-MM-DD).
+
+    Returns:
+        pd.DataFrame: Stock data including Date, Open, High, Low, Close, and Volume.
+    """
+    stock_data = yf.download(ticker, start=start_date, end=end_date)
+    stock_data.reset_index(inplace=True)
+    return stock_data
+
+# Step 2: Prepare data for the LSTM model
+def prepare_data(df):
+    """
+    Prepares the stock data for the LSTM model by scaling the 'Close' price.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing the stock data.
+
+    Returns:
+        scaled_data (np.array): Normalized stock prices for training the model.
+        scaler (MinMaxScaler): Scaler used to normalize and later denormalize predictions.
+    """
+    scaler = MinMaxScaler(feature_range=(0, 1))
+    close_prices = df['Close'].values.reshape(-1, 1)
+    scaled_data = scaler.fit_transform(close_prices)
+    return scaled_data, scaler
+
+# Step 3: Build the LSTM model
+def build_model(input_shape):
+    """
+    Builds and compiles the LSTM model for stock price prediction.
+
+    Args:
+        input_shape (tuple): Shape of the input data for the LSTM model.
+
+    Returns:
+        tf.keras.Model: Compiled LSTM model.
+    """
+    model = tf.keras.Sequential([
+        tf.keras.layers.LSTM(50, return_sequences=True, input_shape=input_shape),
+        tf.keras.layers.LSTM(50, return_sequences=False),
+        tf.keras.layers.Dense(25),
+        tf.keras.layers.Dense(1)
+    ])
+    model.compile(optimizer='adam', loss='mean_squared_error')
+    return model
+
+# Step 4: Train the LSTM model
+def train_model(model, train_data, epochs=5):
+    """
+    Trains the LSTM model using the scaled stock price data.
+
+    Args:
+        model (tf.keras.Model): The LSTM model to be trained.
+        train_data (np.array): Scaled stock price data for training.
+        epochs (int): Number of training epochs.
+
+    Returns:
+        model (tf.keras.Model): The trained LSTM model.
+    """
+    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))
+    
+    model.fit(X_train, y_train, epochs=epochs, batch_size=32, verbose=0)
+    return model
+
+# Step 5: Predict future stock prices
+def predict_future(model, last_data, steps=90):
+    """
+    Predicts future stock prices using the trained LSTM model.
+
+    Args:
+        model (tf.keras.Model): The trained LSTM model.
+        last_data (np.array): The last 60 days of stock price data.
+        steps (int): Number of future days to predict.
+
+    Returns:
+        predictions (list): Predicted stock prices for the future.
+    """
+    predictions = []
+    input_data = last_data[-60:].reshape(1, -1)
+    
+    for _ in range(steps):
+        predicted_price = model.predict(input_data.reshape(1, 60, 1), verbose=0)
+        predictions.append(predicted_price[0][0])
+        input_data = np.append(input_data[0][1:], predicted_price)
+    
+    return predictions
+
+# Step 6: Plot historical and predicted stock prices
+def plot_predictions(data, predicted_prices, scaler):
+    """
+    Plots the historical stock prices and the predicted future stock prices.
+
+    Args:
+        data (pd.DataFrame): DataFrame containing historical stock data.
+        predicted_prices (list): Predicted stock prices for future dates.
+        scaler (MinMaxScaler): Scaler to inverse transform the predicted prices.
+    """
+    last_60_days = data['Close'][-60:].values.reshape(-1, 1)
+    predicted_prices = np.array(predicted_prices).reshape(-1, 1)
+    predicted_prices = scaler.inverse_transform(predicted_prices)
+
+    # Plot historical data
+    plt.figure(figsize=(14,6))
+    plt.plot(data['Close'], label="Historical Prices")
+
+    # Plot predicted data
+    future_days = range(len(data), len(data) + len(predicted_prices))
+    plt.plot(future_days, predicted_prices, label="Predicted Prices")
+    plt.title("Stock Price Prediction")
+    plt.xlabel("Days")
+    plt.ylabel("Stock Price")
+    plt.legend()
+    plt.show()
+
+# Step 7: Gradio Interface Function
+def stock_prediction_app(ticker, start_date, end_date):
+    """
+    The core function for the Gradio app. Fetches stock data, trains the LSTM model,
+    predicts future prices, and visualizes the results.
+
+    Args:
+        ticker (str): Stock ticker symbol selected by the user.
+        start_date (str): Start date selected by the user.
+        end_date (str): End date selected by the user.
+
+    Returns:
+        None (Displays a plot of historical and predicted stock prices).
+    """
+    # Fetch stock data
+    data = fetch_stock_data(ticker, start_date, end_date)
+    
+    # Prepare data for the LSTM model
+    scaled_data, scaler = prepare_data(data)
+    
+    # Build and train the LSTM model
+    model = build_model((60, 1))
+    model = train_model(model, scaled_data)
+    
+    # Predict future prices for the next 90 days
+    predicted_prices = predict_future(model, scaled_data)
+    
+    # Plot historical and predicted prices
+    plot_predictions(data, predicted_prices, scaler)
+
+# Step 8: Gradio UI Setup
+tickers = ["AAPL", "GOOGL", "MSFT", "AMZN", "TSLA", "META", "NFLX", "NVDA", "BABA", "BA"]
+
+# Create the Gradio interface
+ui = gr.Interface(
+    fn=stock_prediction_app,
+    inputs=[
+        gr.Dropdown(tickers, label="Select Stock Ticker"),
+        gr.inputs.Date(label="Start Date"),
+        gr.inputs.Date(label="End Date")
+    ],
+    outputs="plot",
+    title="Stock Prediction App",
+    description="Select a stock ticker and date range to predict future prices."
+)
+
+# Launch the app
+ui.launch()