Update app.py

app.py

@@ -2,93 +2,221 @@ import yfinance as yf
 import pandas as pd
 import numpy as np
 import tensorflow as tf
-import gradio as gr
+from tensorflow.keras import layers, models
 import matplotlib.pyplot as plt
-from sklearn.preprocessing import MinMaxScaler
+import gradio as gr
+from datetime import datetime, timedelta
+
+# Ensure matplotlib does not require a display environment
+import matplotlib
+matplotlib.use('Agg')
+
+# Define the stock tickers
+STOCK_TICKERS = [
+    'AAPL', 'GOOGL', 'MSFT', 'AMZN', 'TSLA',
+    'FB', 'NVDA', 'JPM', 'V', 'DIS'
+]
 
 def fetch_data(ticker, start_date, end_date):
-    # Fetch historical data for the given ticker symbol
+    """
+    Fetch historical stock data from yfinance.
+
+    Args:
+        ticker (str): Stock ticker symbol.
+        start_date (str): Start date in 'YYYY-MM-DD'.
+        end_date (str): End date in 'YYYY-MM-DD'.
+
+    Returns:
+        pd.DataFrame: Historical stock data.
+    """
     data = yf.download(ticker, start=start_date, end=end_date)
     return data
 
-def prepare_data(data):
-    # Preprocessing
-    scaler = MinMaxScaler(feature_range=(0, 1))
-    scaled_data = scaler.fit_transform(data['Close'].values.reshape(-1, 1))
+def preprocess_data(data):
+    """
+    Preprocess the stock data for model training.
 
-    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])
-    
-    return np.array(x_train), np.array(y_train), scaler
-
-def create_model(input_shape):
-    model = tf.keras.Sequential()
-    model.add(tf.keras.layers.LSTM(units=50, return_sequences=True, input_shape=input_shape))
-    model.add(tf.keras.layers.LSTM(units=50, return_sequences=False))
-    model.add(tf.keras.layers.Dense(units=25))
-    model.add(tf.keras.layers.Dense(units=1))  # Output layer
-    model.compile(optimizer='adam', loss='mean_squared_error')
+    Args:
+        data (pd.DataFrame): Raw stock data.
+
+    Returns:
+        np.ndarray, np.ndarray: Features and labels.
+    """
+    # Calculate moving averages
+    data['MA10'] = data['Close'].rolling(window=10).mean()
+    data['MA20'] = data['Close'].rolling(window=20).mean()
+
+    # Drop NaN values
+    data = data.dropna()
+
+    # Features: Close, MA10, MA20
+    features = data[['Close', 'MA10', 'MA20']].values
+
+    # Labels: 1 if next day's Close > today's Close, else 0
+    data['Target'] = np.where(data['Close'].shift(-1) > data['Close'], 1, 0)
+    labels = data['Target'].values[:-1]
+    features = features[:-1]
+
+    return features, labels
+
+def build_model(input_shape):
+    """
+    Build and compile the TensorFlow model.
+
+    Args:
+        input_shape (int): Number of features.
+
+    Returns:
+        tf.keras.Model: Compiled model.
+    """
+    model = models.Sequential([
+        layers.Dense(64, activation='relu', input_shape=(input_shape,)),
+        layers.Dense(32, activation='relu'),
+        layers.Dense(1, activation='sigmoid')  # Binary classification
+    ])
+
+    model.compile(optimizer='adam',
+                  loss='binary_crossentropy',
+                  metrics=['accuracy'])
     return model
 
-def predict_next_days(model, last_60_days, scaler):
-    last_60_days = np.array(last_60_days).reshape(-1, 1)
-    last_60_days_scaled = scaler.transform(last_60_days)
+# Train the model for each stock ticker and store in a dictionary
+models_dict = {}
+
+for ticker in STOCK_TICKERS:
+    # Fetch data for the past 5 years
+    end = datetime.today()
+    start = end - timedelta(days=5*365)
+    data = fetch_data(ticker, start.strftime('%Y-%m-%d'), end.strftime('%Y-%m-%d'))
+
+    if data.empty:
+        print(f"No data found for {ticker}. Skipping...")
+        continue
 
-    X_test = []
-    X_test.append(last_60_days_scaled)
-    X_test = np.array(X_test)
+    features, labels = preprocess_data(data)
+    model = build_model(features.shape[1])
+    model.fit(features, labels, epochs=10, batch_size=32, verbose=0)
+
+    models_dict[ticker] = model
+    print(f"Model trained for {ticker}")
+
+def predict_stock(ticker, start_date, end_date):
+    """
+    Predict whether to Buy or Sell the stock based on user input.
+
+    Args:
+        ticker (str): Selected stock ticker.
+        start_date (str): Training start date.
+        end_date (str): Training end date.
+
+    Returns:
+        dict: Prediction results and graph.
+    """
+    # Fetch data
+    data = fetch_data(ticker, start_date, end_date)
+
+    if data.empty:
+        return {
+            "Percentage Change": "No data available for the selected dates.",
+            "Highest Price": "N/A",
+            "Lowest Price": "N/A",
+            "Prediction": "N/A",
+            "Graph": None
+        }
+
+    # Preprocess data
+    features, labels = preprocess_data(data)
+
+    if features.size == 0:
+        return {
+            "Percentage Change": "Insufficient data after preprocessing.",
+            "Highest Price": "N/A",
+            "Lowest Price": "N/A",
+            "Prediction": "N/A",
+            "Graph": None
+        }
+
+    # Get the latest features for prediction
+    latest_data = data[['Close', 'MA10', 'MA20']].values[-1].reshape(1, -1)
+
+    # Predict using the trained model
+    model = models_dict.get(ticker)
+    if not model:
+        return {
+            "Percentage Change": "Model not found for the selected ticker.",
+            "Highest Price": "N/A",
+            "Lowest Price": "N/A",
+            "Prediction": "N/A",
+            "Graph": None
+        }
+
+    prediction = model.predict(latest_data)
+    prediction_label = "Buy" if prediction[0][0] > 0.5 else "Sell"
+
+    # Calculate percentage change
+    start_close = data['Close'].iloc[0]
+    latest_close = data['Close'].iloc[-1]
+    percent_change = ((latest_close - start_close) / start_close) * 100
+
+    # Highest and Lowest values
+    highest = data['Close'].max()
+    lowest = data['Close'].min()
+
+    # Plot historical data
+    plt.figure(figsize=(10,5))
+    plt.plot(data.index, data['Close'], label='Historical Close')
     
-    predicted_price = model.predict(X_test)
-    predicted_price = scaler.inverse_transform(predicted_price)  # Reverse scaling
-    return predicted_price[0][0]
-
-def plot_graph(data, predicted_prices):
-    plt.figure(figsize=(14, 5))
-    plt.plot(data['Close'], label='Historical Prices', color='blue')
-    plt.axhline(y=predicted_prices, color='red', linestyle='--', label='Predicted Price')
-    plt.title('Stock Price Prediction')
+    # Predict future 3 months (approx 63 trading days)
+    future_days = 63
+    # For simplicity, we'll extend the latest close with random walk
+    future_prices = [latest_close]
+    for _ in range(future_days):
+        change_percent = np.random.uniform(-0.02, 0.02)  # Simulate small changes
+        new_price = future_prices[-1] * (1 + change_percent)
+        future_prices.append(new_price)
+    
+    future_dates = pd.date_range(data.index[-1] + timedelta(days=1), periods=future_days+1, freq='B')
+    plt.plot(future_dates, future_prices[1:], label='Predicted Close')
     plt.xlabel('Date')
-    plt.ylabel('Stock Price')
+    plt.ylabel('Price')
+    plt.title(f'{ticker} Historical and Predicted Performance')
     plt.legend()
-    plt.show()
+    plt.tight_layout()
+    plt.savefig('performance.png')
+    plt.close()
 
-def stock_prediction(ticker, start_date, end_date):
-    data = fetch_data(ticker, start_date, end_date)
-    x_train, y_train, scaler = prepare_data(data)
-    model = create_model((x_train.shape[1], 1))
-    model.fit(x_train, y_train, batch_size=1, epochs=1)
-
-    # Make predictions
-    last_60_days = data['Close'].values[-60:]
-    predicted_price = predict_next_days(model, last_60_days, scaler)
-
-    # Calculate percentage change, highest, and lowest
-    percentage_change = ((data['Close'][-1] - data['Close'][0]) / data['Close'][0]) * 100
-    highest_value = data['Close'].max()
-    lowest_value = data['Close'].min()
-
-    plot_graph(data, predicted_price)
-
-    return {
-        "Predicted Price": predicted_price,
-        "Percentage Change": percentage_change,
-        "Highest Value": highest_value,
-        "Lowest Value": lowest_value,
+    # Prepare the result
+    result = {
+        "Percentage Change": f"{percent_change:.2f}%",
+        "Highest Price": f"${highest:.2f}",
+        "Lowest Price": f"${lowest:.2f}",
+        "Prediction": prediction_label,
+        "Graph": 'performance.png'
     }
 
-# UI setup
-stock_tickers = ["AAPL", "MSFT", "GOOGL", "AMZN", "TSLA", "FB", "NFLX", "NVDA", "INTC", "AMD"]
+    return result
 
-gr.Interface(
-    fn=stock_prediction,
+# Define Gradio Interface
+iface = gr.Interface(
+    fn=predict_stock,
     inputs=[
-        gr.Dropdown(choices=stock_tickers, label="Stock Ticker"),
-        gr.DatePicker(label="Start Date"),  # Changed to DatePicker
-        gr.DatePicker(label="End Date"),      # Changed to DatePicker
+        gr.Dropdown(choices=STOCK_TICKERS, label="Select Stock Ticker"),
+        gr.DatePicker(label="Start Date"),
+        gr.DatePicker(label="End Date")
     ],
-    outputs="json",
-    title="Stock Prediction App",
-    description="This app predicts stock prices based on historical data."
-).launch()
+    outputs=[
+        gr.Textbox(label="Percentage Change"),
+        gr.Textbox(label="Highest Price"),
+        gr.Textbox(label="Lowest Price"),
+        gr.Textbox(label="Buy/Sell Prediction"),
+        gr.Image(label="Performance Graph")
+    ],
+    title="📈 Stock Buy/Sell Prediction App",
+    description=(
+        "Select a stock ticker and a date range to predict whether to **Buy** or **Sell** the stock. "
+        "View the percentage change, highest and lowest prices, and a performance graph."
+    )
+)
+
+# Launch the app
+iface.launch()