Update app.py

app.py

@@ -1,252 +1,100 @@
 import yfinance as yf
-import pandas as pd
-import numpy as np
 import tensorflow as tf
-from tensorflow.keras import layers, models
+import numpy as np
+import pandas as pd
 import matplotlib.pyplot as plt
 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 stock data from yfinance.
+from datetime import datetime
 
-    Args:
-        ticker (str): Stock ticker symbol.
-        start_date (str): Start date in 'YYYY-MM-DD'.
-        end_date (str): End date in 'YYYY-MM-DD'.
+# Stock tickers for dropdown
+stock_tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA', 'NFLX', 'FB', 'NVDA', 'JPM', 'BAC']
 
-    Returns:
-        pd.DataFrame: Historical stock data.
-    """
+# Function to download stock data from Yahoo Finance
+def fetch_stock_data(ticker, start_date, end_date):
     data = yf.download(ticker, start=start_date, end=end_date)
     return data
 
-def preprocess_data(data):
-    """
-    Preprocess the stock data for model training.
-
-    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
+# Function to train LSTM model and predict stock prices
+def train_lstm(data):
+    # Preprocessing and creating training dataset
+    data['Close'] = data['Close'].fillna(method='ffill')  # Forward-fill to handle NaNs
+    scaled_data = data['Close'].values.reshape(-1, 1)
+    training_data = scaled_data[:int(len(scaled_data) * 0.8)]  # 80% data for training
+    test_data = scaled_data[int(len(scaled_data) * 0.8):]
+
+    # Creating sequences for LSTM input
+    def create_sequences(data, seq_length):
+        X, y = [], []
+        for i in range(len(data) - seq_length):
+            X.append(data[i:i + seq_length])
+            y.append(data[i + seq_length])
+        return np.array(X), np.array(y)
+
+    seq_length = 60  # Using 60 days for prediction
+    X_train, y_train = create_sequences(training_data, seq_length)
+
+    # Define the LSTM model
+    model = tf.keras.Sequential([
+        tf.keras.layers.LSTM(50, return_sequences=True, input_shape=(X_train.shape[1], 1)),
+        tf.keras.layers.LSTM(50, return_sequences=False),
+        tf.keras.layers.Dense(25),
+        tf.keras.layers.Dense(1)
     ])
 
-    model.compile(optimizer='adam',
-                  loss='binary_crossentropy',
-                  metrics=['accuracy'])
-    return model
-
-# 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
-
-    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
-        }
+    # Compile and train the model
+    model.compile(optimizer='adam', loss='mean_squared_error')
+    model.fit(X_train, y_train, batch_size=1, epochs=1)  # Short training for demo, increase epochs for better results
 
-    # Preprocess data
-    features, labels = preprocess_data(data)
+    # Predict future prices
+    X_test, _ = create_sequences(test_data, seq_length)
+    predictions = model.predict(X_test)
 
-    if features.size == 0:
-        return {
-            "Percentage Change": "Insufficient data after preprocessing.",
-            "Highest Price": "N/A",
-            "Lowest Price": "N/A",
-            "Prediction": "N/A",
-            "Graph": None
-        }
+    return predictions, data.index[-len(predictions):]
 
-    # 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')
-    
-    # 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')
+# Function to plot historical and predicted prices
+def plot_stock_data(data, predictions, pred_dates):
+    plt.figure(figsize=(10,6))
+    plt.plot(data['Close'], label='Historical Data')
+    plt.plot(pred_dates, predictions, label='Predicted Data')
     plt.xlabel('Date')
-    plt.ylabel('Price')
-    plt.title(f'{ticker} Historical and Predicted Performance')
+    plt.ylabel('Close Price (USD)')
     plt.legend()
-    plt.tight_layout()
-    plt.savefig('performance.png')
-    plt.close()
-
-    # 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'
-    }
-
-    return result
-
-# Define Gradio Interface
-iface = gr.Interface(
-    fn=predict_stock,
-    inputs=[
-        gr.Dropdown(choices=STOCK_TICKERS, label="Select Stock Ticker"),
-        gr.DatePicker(label="Start Date"),
-        gr.DatePicker(label="End Date")
-    ],
-    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()
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.layers import Dense, Input
-
-def create_model(input_shape):
-    model = Sequential()
-    model.add(Input(shape=(input_shape,)))  # Explicitly define input shape
-    model.add(Dense(64, activation='relu'))
-    model.add(Dense(32, activation='relu'))
-    model.add(Dense(1, activation='sigmoid'))
-
-    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
-    return model
-data.loc[:, 'Target'] = np.where(data['Close'].shift(-1) > data['Close'], 1, 0)
-import gradio as gr
-
-def predict_stock(ticker, start_date, end_date):
-    # Your prediction logic
-    return "Prediction result"
+    plt.grid()
+    plt.show()
+
+# Main function to wrap everything into Gradio interface
+def stock_prediction(ticker, start_date, end_date):
+    data = fetch_stock_data(ticker, start_date, end_date)
+    predictions, pred_dates = train_lstm(data)
+    plot_stock_data(data, predictions, pred_dates)
+
+    # Calculate percentage change, highest and lowest values
+    percentage_change = ((data['Close'][-1] - data['Close'][0]) / data['Close'][0]) * 100
+    highest_value = data['Close'].max()
+    lowest_value = data['Close'].min()
+    
+    # Buy/Sell decision based on prediction (buy if next value is higher)
+    decision = 'Buy' if predictions[-1] > data['Close'][-1] else 'Sell'
+    
+    return f"Percentage Change: {percentage_change:.2f}%", f"Highest Value: {highest_value:.2f}", f"Lowest Value: {lowest_value:.2f}", f"Decision: {decision}"
 
+# Gradio UI
 interface = gr.Interface(
-    fn=predict_stock,
+    fn=stock_prediction,
     inputs=[
-        gr.inputs.Dropdown(['AAPL', 'MSFT', 'GOOG', 'AMZN', 'TSLA'], label="Stock Ticker"),
-        gr.inputs.Date(label="Start Date"),  # Replace DatePicker with Date
+        gr.inputs.Dropdown(choices=stock_tickers, label="Select Stock Ticker"),
+        gr.inputs.Date(label="Start Date"),
         gr.inputs.Date(label="End Date")
     ],
-    outputs="text"
+    outputs=[
+        gr.outputs.Textbox(label="Percentage Change"),
+        gr.outputs.Textbox(label="Highest Value"),
+        gr.outputs.Textbox(label="Lowest Value"),
+        gr.outputs.Textbox(label="Prediction: Buy/Sell")
+    ],
+    title="Stock Prediction App",
+    description="Predict if you should buy or sell a stock based on historical performance."
 )
 
 interface.launch()
+