Update app.py

app.py

@@ -1,137 +1,80 @@
+import gradio as gr
 import yfinance as yf
-import pandas as pd
 import numpy as np
-import tensorflow as tf
-import gradio as gr
+import pandas as pd
 import matplotlib.pyplot as plt
-from sklearn.preprocessing import MinMaxScaler
+from sklearn.linear_model import LinearRegression
 
-# Function to fetch stock data from Yahoo Finance
-def fetch_stock_data(ticker, start_date, end_date):
+# Function to fetch data
+def fetch_data(ticker, start_date, end_date):
     stock_data = yf.download(ticker, start=start_date, end=end_date)
-    if stock_data.empty:
-        return None
     return stock_data
 
-# Function to prepare the data for LSTM
-def prepare_data(data):
-    scaler = MinMaxScaler(feature_range=(0, 1))
-    scaled_data = scaler.fit_transform(data['Close'].values.reshape(-1, 1))
-
-    # Create sequences for LSTM
-    def create_sequences(data, time_step=60):
-        X, y = [], []
-        for i in range(len(data) - time_step - 1):
-            X.append(data[i:i + time_step])
-            y.append(data[i + time_step])
-        return np.array(X), np.array(y)
-
-    # Train-test split (80% train, 20% test)
-    train_size = int(len(scaled_data) * 0.8)
-    train_data, test_data = scaled_data[:train_size], scaled_data[train_size:]
-
-    X_train, y_train = create_sequences(train_data)
-    X_test, y_test = create_sequences(test_data)
-
-    return X_train, y_train, X_test, y_test, scaler
-
-# Function to build LSTM model
-def build_lstm_model(input_shape):
-    model = tf.keras.Sequential([
-        tf.keras.layers.LSTM(50, return_sequences=True, input_shape=(input_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='mean_squared_error')
-    return model
-
-# Function to train the LSTM model
-def train_model(X_train, y_train):
-    model = build_lstm_model(X_train.shape)
-    model.fit(X_train, y_train, batch_size=1, epochs=1)
-    return model
-
-# Function to make predictions using the trained model
-def make_predictions(model, X_test, scaler):
-    predictions = model.predict(X_test)
-    return scaler.inverse_transform(predictions)
-
-# Function to calculate the metrics (percentage change, highest, lowest, buy/sell)
-def calculate_metrics(data, predictions):
-    start_value = data['Close'][0]
-    end_value = predictions[-1][0]
-    percentage_change = ((end_value - start_value) / start_value) * 100
-
-    highest_value = data['Close'].max()
-    lowest_value = data['Close'].min()
-
-    decision = "Buy" if end_value > start_value else "Sell"
-
-    return percentage_change, highest_value, lowest_value, decision
-
-# Function to plot the graph of historical vs predicted data
-def plot_graph(data, predictions, ticker):
-    plt.figure(figsize=(12, 6))
-    plt.plot(data.index, data['Close'], label="Historical Prices", color='blue')
-    plt.plot(data.index[len(data) - len(predictions):], predictions, label="Predicted Prices", color='red')
-    plt.title(f'{ticker} Stock Price Prediction')
-    plt.xlabel('Date')
-    plt.ylabel('Price (USD)')
+# Function to predict future prices
+def predict_stock(ticker, start_date, end_date):
+    stock_data = fetch_data(ticker, start_date, end_date)
+    
+    stock_data['Date'] = pd.to_datetime(stock_data.index)
+    stock_data['Days'] = (stock_data['Date'] - stock_data['Date'].min()).dt.days
+    
+    X = stock_data['Days'].values.reshape(-1, 1)
+    y = stock_data['Close'].values
+    
+    model = LinearRegression()
+    model.fit(X, y)
+    
+    future_days = np.array(range(stock_data['Days'].max() + 1, stock_data['Days'].max() + 90)).reshape(-1, 1)
+    future_prices = model.predict(future_days)
+    
+    return future_prices, stock_data
+
+# Function to visualize stock data
+def plot_stock_data(ticker, start_date, end_date):
+    future_prices, stock_data = predict_stock(ticker, start_date, end_date)
+    
+    plt.figure(figsize=(10, 6))
+    plt.plot(stock_data['Date'], stock_data['Close'], label="Historical Prices")
+    future_dates = pd.date_range(stock_data['Date'].max() + pd.Timedelta(days=1), periods=90)
+    plt.plot(future_dates, future_prices, label="Predicted Future Prices")
+    
+    plt.title(f"{ticker} Stock Price Prediction")
+    plt.xlabel("Date")
+    plt.ylabel("Price")
     plt.legend()
     plt.grid(True)
-    plt.show()
-
-# Gradio interface function
-def stock_predictor(ticker, start_date, end_date):
-    stock_data = fetch_stock_data(ticker, start_date, end_date)
-
-    if stock_data is None or len(stock_data) == 0:
-        return "Error: No data found. Please select a valid date range."
-
-    # Prepare data for LSTM
-    X_train, y_train, X_test, y_test, scaler = prepare_data(stock_data)
-
-    # Train the model
-    model = train_model(X_train, y_train)
-
-    # Make predictions
-    predictions = make_predictions(model, X_test, scaler)
-
-    # Calculate buy/sell decision and metrics
-    percentage_change, highest_value, lowest_value, decision = calculate_metrics(stock_data, predictions)
-
-    # Plot the historical vs predicted data
-    plot_graph(stock_data, predictions, ticker)
-
-    # Return the calculated metrics
-    return {
-        "Percentage Change": f"{percentage_change:.2f}%",
-        "Highest Value": f"${highest_value:.2f}",
-        "Lowest Value": f"${lowest_value:.2f}",
-        "Prediction (Buy/Sell)": decision
-    }
-
-# List of stock tickers for the dropdown
-tickers = ['AAPL', 'GOOGL', 'AMZN', 'MSFT', 'TSLA', 'NFLX', 'NVDA', 'META', 'BABA', 'INTC']
-
-# Gradio interface design
-gr_interface = gr.Interface(
-    fn=stock_predictor,
-    inputs=[
-        gr.Dropdown(choices=tickers, label="Select Stock Ticker"),
-        gr.inputs.Date(label="Start Date"),
-        gr.inputs.Date(label="End Date")
-    ],
-    outputs=[
-        gr.Label(label="Percentage Change"),
-        gr.Label(label="Highest Value"),
-        gr.Label(label="Lowest Value"),
-        gr.Label(label="Prediction (Buy/Sell)"),
-    ],
-    title="Stock Prediction App",
-    description="This app predicts stock prices and helps users decide whether to buy or sell."
-)
-
-# Launch the Gradio interface
-gr_interface.launch()
+    
+    return plt.gcf()
+
+# Gradio Interface
+def stock_prediction_interface(ticker, start_date, end_date):
+    stock_data = fetch_data(ticker, start_date, end_date)
+    price_change = (stock_data['Close'].iloc[-1] - stock_data['Close'].iloc[0]) / stock_data['Close'].iloc[0] * 100
+    highest_price = stock_data['High'].max()
+    lowest_price = stock_data['Low'].min()
+    
+    future_prices, _ = predict_stock(ticker, start_date, end_date)
+    decision = "Buy" if future_prices[-1] > stock_data['Close'].iloc[-1] else "Sell"
+    
+    graph = plot_stock_data(ticker, start_date, end_date)
+    
+    return f"Percentage Change: {price_change:.2f}%\nHighest Price: {highest_price}\nLowest Price: {lowest_price}\nDecision: {decision}", graph
+
+# Gradio app UI
+ticker_list = ['AAPL', 'GOOGL', 'MSFT', 'AMZN', 'TSLA', 'META', 'NFLX', 'NVDA', 'BABA', 'INTC']
+
+# Update to use gr.components instead of gr.inputs
+with gr.Blocks() as demo:
+    ticker_input = gr.components.Dropdown(choices=ticker_list, label="Stock Ticker")
+    start_date_input = gr.components.Date(label="Start Date")
+    end_date_input = gr.components.Date(label="End Date")
+    
+    output_text = gr.components.Textbox(label="Prediction Results")
+    output_plot = gr.components.Plot(label="Stock Price Plot")
+    
+    gr.components.Button("Predict").click(
+        stock_prediction_interface, 
+        inputs=[ticker_input, start_date_input, end_date_input], 
+        outputs=[output_text, output_plot]
+    )
+
+demo.launch()