Update app.py

app.py

@@ -1,173 +1,91 @@
-import os
+# Import necessary libraries
+import gradio as gr
 import yfinance as yf
 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
-import gradio as gr
+from neuralprophet import NeuralProphet
 from datetime import datetime
-import requests  # To get the exchange rate
-
-# Disable GPU usage and oneDNN optimizations
-os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
-os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
 
-# Helper function to get the current USD to INR exchange rate
-def get_usd_to_inr_rate():
-    try:
-        response = requests.get('https://api.exchangerate-api.com/v4/latest/USD')
-        data = response.json()
-        return data['rates']['INR']
-    except Exception as e:
-        print(f"Error fetching exchange rate: {e}")
-        return 82.0  # Use a fallback conversion rate (adjust if necessary)
-
-# 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')
-        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
+# Function to fetch historical stock data
 def get_stock_data(ticker, start_date, end_date):
-    try:
-        stock_data = yf.download(ticker, start=start_date, end=end_date)
-    except Exception as e:
-        print(f"Error fetching data: {e}")
-        return None, None, None
-    
-    # If stock data is empty, attempt to adjust the date range
-    if stock_data.empty:
-        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
+    stock_data = yf.download(ticker, start=start_date, end=end_date)
+    stock_data.reset_index(inplace=True)  # Reset index to use dates properly
+    return stock_data
 
-# Preprocess the data for the LSTM model
-def preprocess_data(stock_data):
-    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(close_prices)
+# Function to preprocess data for NeuralProphet model
+def prepare_data_for_neuralprophet(stock_data):
+    df = stock_data[['Date', 'Close']].rename(columns={'Date': 'ds', 'Close': 'y'})
+    return df
+
+# Function to train NeuralProphet model and make predictions
+def predict_stock(stock_data, period):
+    df = prepare_data_for_neuralprophet(stock_data)
+    model = NeuralProphet()  # Initialize NeuralProphet model
+    model.fit(df)  # Fit the model with the historical stock data
     
-    return scaled_data, scaler
+    # Make future predictions
+    future = model.make_future_dataframe(df, periods=period)  # Create a future dataframe for predictions
+    forecast = model.predict(future)  # Predict future stock prices
+    return forecast[['ds', 'yhat1']]
 
-# 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=1))  # Predicting the next closing price
-    model.compile(optimizer='adam', loss='mean_squared_error')
-    return model
+# Function to get buy/sell recommendation based on percentage change
+def get_recommendation(stock_data):
+    change_percent = ((stock_data['Close'].iloc[-1] - stock_data['Close'].iloc[0]) / stock_data['Close'].iloc[0]) * 100
+    if change_percent > 0:
+        return "Buy"
+    else:
+        return "Sell"
 
-# Save and load models to avoid re-training
-def save_model(model, file_name):
-    model.save(file_name)
+# Function to plot stock data
+def plot_stock(stock_data, forecast):
+    plt.figure(figsize=(10, 5))
+    plt.plot(stock_data['Date'], stock_data['Close'], label='Historical Closing Price')
+    plt.plot(forecast['ds'], forecast['yhat1'], label='Predicted Closing Price')
+    plt.xlabel("Date")
+    plt.ylabel("Stock Price")
+    plt.title("Stock Price Prediction")
+    plt.legend()
+    plt.grid(True)
+    plt.savefig("stock_prediction_plot.png")  # Save the plot as an image
+    plt.close()
+    return "stock_prediction_plot.png"
 
-def load_trained_model(file_name):
-    if os.path.exists(file_name):
-        return load_model(file_name)
-    else:
-        return None
+# Main function to handle user inputs and return results
+def stock_prediction_app(ticker, start_date, end_date, prediction_period):
+    stock_data = get_stock_data(ticker, start_date, end_date)  # Fetch historical stock data
+    forecast = predict_stock(stock_data, prediction_period)  # Predict future prices
+    recommendation = get_recommendation(stock_data)  # Get buy/sell recommendation
+    plot_file = plot_stock(stock_data, forecast)  # Plot stock data and predictions
 
-# Train and make predictions
-def predict_stock(stock_data, scaler, model):
-    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)
-    
-    return predicted_price
+    # Get the highest and lowest closing prices in the historical data
+    high = stock_data['Close'].max()
+    low = stock_data['Close'].min()
+    percentage_change = ((stock_data['Close'].iloc[-1] - stock_data['Close'].iloc[0]) / stock_data['Close'].iloc[0]) * 100
 
-# Main app function
-def stock_predictor(ticker, start_date, end_date):
-    usd_to_inr = get_usd_to_inr_rate()  # Get the USD to INR conversion rate
-    
-    # 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
-    scaled_data, scaler = preprocess_data(stock_data)
-    
-    # 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
-        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)
-    
-    # Convert predicted price to INR
-    predicted_price_inr = predicted_price[0][0] * usd_to_inr
-    
-    # Historical vs Predicted Graph
-    plt.figure(figsize=(14, 7))
-    plt.plot(stock_data['Close'], color="blue", label="Historical Prices (USD)")
-    plt.scatter(len(stock_data), predicted_price[0], color="red", label="Predicted Price (USD)")
-    plt.title(f"{ticker} Stock Price Prediction")
-    plt.xlabel('Date')
-    plt.ylabel('Price (USD)')
-    plt.legend()
-    plt.show()
+    return high, low, percentage_change, recommendation, plot_file
 
-    # Return the predicted price in INR
-    return f"Predicted Stock Price for {ticker} tomorrow: ₹{predicted_price_inr:.2f} (INR)"
+# Define the stock tickers for the dropdown
+tickers = ['AAPL', 'GOOGL', 'AMZN', 'MSFT', 'TSLA', 'NFLX', 'NVDA', 'INTC', 'AMD', 'FB']
 
-# 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()
+# Create the Gradio interface using the latest Gradio API
+app = gr.Interface(
+    fn=stock_prediction_app,
+    inputs=[
+        gr.Dropdown(choices=tickers, label="Stock Ticker"),
+        gr.Textbox(label="Start Date (YYYY-MM-DD)"),
+        gr.Textbox(label="End Date (YYYY-MM-DD)"),
+        gr.Slider(1, 365, label="Prediction Period (Days)")
+    ],
+    outputs=[
+        gr.Textbox(label="Highest Value"),
+        gr.Textbox(label="Lowest Value"),
+        gr.Textbox(label="Percentage Change"),
+        gr.Textbox(label="Buy/Sell Recommendation"),
+        gr.Image(type="filepath", label="Stock Performance and Prediction Graph")
+    ],
+    title="AI-Powered Stock Prediction App",
+    description="Predict future stock prices, calculate highest and lowest prices, percentage change, and get a buy/sell recommendation based on historical data."
+)
 
-# Run the app
-build_ui()
+# Launch the Gradio app
+app.launch()