Update app.py

app.py

@@ -1,123 +1,167 @@
+import os
 import yfinance as yf
-import gradio as gr
-import numpy as np
 import pandas as pd
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.models import Sequential, load_model
+from tensorflow.keras.layers import LSTM, Dense, Dropout
 import matplotlib.pyplot as plt
-from datetime import datetime, timedelta
-from sklearn.preprocessing import MinMaxScaler
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.layers import Dense, LSTM
-
-# Function to load stock data
-def load_stock_data(ticker, start, end):
-    stock = yf.download(ticker, start=start, end=end)
-    return stock
-
-# Function to preprocess the data for model training
-def preprocess_data(stock):
-    data = stock[['Close']]
+import gradio as gr
+from datetime import datetime
+
+# Disable GPU usage and oneDNN optimizations
+os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
+os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+
+# Helper function to handle date adjustments and retries if data not found
+def adjust_date_range_if_needed(stock_data, ticker, start_date, end_date):
+    retries = 3  # Number of retries for fetching data
+    while stock_data.empty and retries > 0:
+        start_date = (datetime.strptime(start_date, '%Y-%m-%d') - timedelta(days=1)).strftime('%Y-%m-%d')
+        end_date = (datetime.strptime(end_date, '%Y-%m-%d') - timedelta(days=1)).strftime('%Y-%m-%d')
+        print(f"Retrying with adjusted dates: {start_date} to {end_date}")  # Debugging output
+        stock_data = yf.download(ticker, start=start_date, end=end_date)
+        retries -= 1
+    return stock_data, start_date, end_date
+
+# Define function to validate stock ticker and get stock data
+def get_stock_data(ticker, start_date, end_date):
+    try:
+        stock_data = yf.download(ticker, start=start_date, end=end_date)
+        print(f"Stock data downloaded: {stock_data.shape}")  # Debugging output to check data download
+    except Exception as e:
+        print(f"Error fetching data: {e}")  # Debugging output for data download error
+        return None, None, None
+    
+    # If stock data is empty, attempt to adjust the date range
+    if stock_data.empty:
+        print("No data found for the original date range.")  # Debugging output
+        stock_data, adjusted_start, adjusted_end = adjust_date_range_if_needed(stock_data, ticker, start_date, end_date)
+        if stock_data.empty:
+            return None, None, None  # If still empty after retries, return None
+        return stock_data, adjusted_start, adjusted_end
+    return stock_data, start_date, end_date
+
+# Preprocess the data for the LSTM model
+def preprocess_data(stock_data):
+    # Closing prices
+    close_prices = stock_data['Close'].values
+    close_prices = close_prices.reshape(-1, 1)
+    
+    # Normalize the data
+    from sklearn.preprocessing import MinMaxScaler
     scaler = MinMaxScaler(feature_range=(0, 1))
-    scaled_data = scaler.fit_transform(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)
-    x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
-
-    return x_train, y_train, scaler
+    scaled_data = scaler.fit_transform(close_prices)
+    
+    return scaled_data, scaler
 
-# Function to build the LSTM model
+# 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(Dense(units=25))
-    model.add(Dense(units=1))
-    
+    model.add(Dropout(0.2))
+    model.add(Dense(units=1))  # Predicting the next closing price
     model.compile(optimizer='adam', loss='mean_squared_error')
     return model
 
-# Function to train the model
-def train_model(ticker, start, end):
-    # Load stock data
-    stock_data = load_stock_data(ticker, start, end)
-
+# Save and load models to avoid re-training
+def save_model(model, file_name):
+    model.save(file_name)
+
+def load_trained_model(file_name):
+    if os.path.exists(file_name):
+        return load_model(file_name)
+    else:
+        return None
+
+# Train and make predictions
+def predict_stock(stock_data, scaler, model):
+    # Get the last 60 days of stock data for prediction
+    last_60_days = stock_data[-60:]
+    last_60_days_scaled = scaler.transform(last_60_days)
+    
+    # Prepare the input for prediction
+    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
+    predicted_price = model.predict(X_test)
+    predicted_price = scaler.inverse_transform(predicted_price)
+    
+    print(f"Predicted price: {predicted_price}")  # Debugging output to verify predictions
+    return predicted_price
+
+# Main app function
+def stock_predictor(ticker, start_date, end_date):
+    # Validate if the ticker is available on Yahoo Finance
+    if not ticker:
+        return f"Invalid stock ticker: {ticker}"
+    
+    # Get stock data
+    stock_data, adjusted_start, adjusted_end = get_stock_data(ticker, start_date, end_date)
+    
+    if stock_data is None or stock_data.empty:
+        return f"No data found for {ticker} in the selected or adjusted date range."
+    
     # Preprocess the data
-    x_train, y_train, scaler = preprocess_data(stock_data)
-
-    # Build and train the model
-    model = build_model()
-    model.fit(x_train, y_train, batch_size=1, epochs=1)
-
-    return model, scaler, stock_data
-
-# Function to predict stock prices
-def predict_stock(model, scaler, stock_data):
-    # Use the last 60 days of data for predictions
-    test_data = stock_data[['Close']][-60:].values
-    test_data_scaled = scaler.transform(test_data)
-
-    x_test = []
-    x_test.append(test_data_scaled)
+    scaled_data, scaler = preprocess_data(stock_data)
     
-    x_test = np.array(x_test)
-    x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1))
-
-    # Make predictions
-    predictions = model.predict(x_test)
-    predictions = scaler.inverse_transform(predictions)
-
-    # Plot historical and predicted prices
-    plt.figure(figsize=(10, 6))
-    plt.plot(stock_data.index, stock_data['Close'], label="Historical Prices")
-    future_dates = [stock_data.index[-1] + timedelta(days=i) for i in range(1, 91)]
-    plt.plot(future_dates, predictions.flatten(), label="Predicted Prices")
-    plt.title("Stock Price Prediction")
+    # Try to load a pre-trained model
+    model_file = f"{ticker}_model.h5"
+    model = load_trained_model(model_file)
+    
+    if model is None:
+        # Train the model if pre-trained model is not found
+        print("Training the model...")  # Debugging output for training
+        model = build_model()
+        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)
+        X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))
+        
+        # Train the model (reduced epochs for faster processing)
+        model.fit(X_train, y_train, epochs=2, batch_size=32)  # Reduced epochs
+        
+        # Save the trained model
+        save_model(model, model_file)
+    
+    # Predict stock price for tomorrow
+    predicted_price = predict_stock(scaled_data, scaler, model)
+    
+    # Historical vs Predicted
+    plt.figure(figsize=(14, 7))
+    plt.plot(stock_data['Close'], color="blue", label="Historical Prices")
+    plt.scatter(len(stock_data), predicted_price, color="red", label="Predicted Price for Tomorrow")
+    plt.title(f"{ticker} Stock Price Prediction")
     plt.xlabel('Date')
     plt.ylabel('Price')
     plt.legend()
     plt.show()
 
-    return predictions[-1][0]
-
-# Gradio interface function
-def stock_prediction(ticker, start, end):
-    model, scaler, stock_data = train_model(ticker, start, end)
-    prediction = predict_stock(model, scaler, stock_data)
-
-    start_price = stock_data['Close'].iloc[0]
-    end_price = stock_data['Close'].iloc[-1]
-    percent_change = ((end_price - start_price) / start_price) * 100
-    highest_price = stock_data['Close'].max()
-    lowest_price = stock_data['Close'].min()
+    return f"Predicted Stock Price for {ticker} tomorrow: ${predicted_price[0][0]:.2f}"
 
-    return {
-        "Predicted Next Price": prediction,
-        "Percentage Change": percent_change,
-        "Highest Price": highest_price,
-        "Lowest Price": lowest_price
-    }
-
-# Define stock tickers and default dates
-tickers = ['AAPL', 'GOOG', 'MSFT', 'TSLA', 'AMZN', 'NFLX', 'META', 'NVDA', 'BABA', 'INTC']
-start_default = (datetime.now() - timedelta(days=365)).strftime("%Y-%m-%d")
-end_default = datetime.now().strftime("%Y-%m-%d")
-
-# Gradio interface
-iface = gr.Interface(
-    fn=stock_prediction,
-    inputs=[
-        gr.Dropdown(choices=tickers, label="Select Stock Ticker"),
-        gr.Date(label="Start Date", value=start_default),
-        gr.Date(label="End Date", value=end_default),
-    ],
-    outputs=gr.JSON(label="Prediction and Analysis"),
-    live=True
-)
-
-# Launch the Gradio app
-if __name__ == "__main__":
-    iface.launch()
+# Gradio UI
+def build_ui():
+    stock_tickers = ["AAPL", "TSLA", "AMZN", "MSFT", "GOOGL", "FB", "NFLX", "NVDA", "BABA", "JPM"]
+    
+    # Use Textbox for manual date input (format: YYYY-MM-DD)
+    gr_interface = gr.Interface(
+        fn=stock_predictor,
+        inputs=[
+            gr.Dropdown(stock_tickers, label="Stock Ticker"),
+            gr.Textbox(label="Start Date (YYYY-MM-DD)", value="2022-01-01"),  # Manual start date
+            gr.Textbox(label="End Date (YYYY-MM-DD)", value=datetime.today().strftime("%Y-%m-%d"))  # Manual end date
+        ],
+        outputs="text",
+        title="Stock Price Prediction for Tomorrow"
+    )
+    gr_interface.launch()
+
+# Run the app
+build_ui()