Update app.py

app.py

@@ -1,204 +1,107 @@
+import sys
+import pandas as pd
+import numpy as np
+import tensorflow as tf
 import gradio as gr
+
+print(f"Python version: {sys.version}")
+print(f"Pandas version: {pd.__version__}")
+print(f"Numpy version: {np.__version__}")
+print(f"TensorFlow version: {tf.__version__}")
+print(f"Gradio version: {gr.__version__}")
 import yfinance as yf
-import numpy as np
 import pandas as pd
-import matplotlib.pyplot as plt
-from sklearn.linear_model import LinearRegression
-import matplotlib
-matplotlib.use('Agg')  # Use non-interactive backend
-
-# Date validation function
-def validate_date(date_text):
-    try:
-        pd.to_datetime(date_text)
-        return True
-    except ValueError:
-        return False
 
-# Function to fetch data
 def fetch_data(ticker, start_date, end_date):
-    # Validate the dates
-    if not validate_date(start_date) or not validate_date(end_date):
-        return "Invalid date format. Please use YYYY-MM-DD.", None
-    
-    # Convert input dates from strings to pandas datetime
-    start_date = pd.to_datetime(start_date)
-    end_date = pd.to_datetime(end_date)
-    
-    stock_data = yf.download(ticker, start=start_date, end=end_date)
-    
-    if stock_data.empty:
-        return f"No data found for ticker {ticker} in the specified date range.", None
-    
-    return stock_data
-
-# Function to predict future prices
-def predict_stock(ticker, start_date, end_date):
-    stock_data = fetch_data(ticker, start_date, end_date)
-    
-    if isinstance(stock_data, str):  # In case of an error message from fetch_data
-        return stock_data, None
-    
-    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)
-    
-    if isinstance(future_prices, str):  # In case of an error message
-        return future_prices
-    
-    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)
-    
-    return plt.gcf()
-
-# Gradio Interface
-def stock_prediction_interface(ticker, start_date, end_date):
-    stock_data = fetch_data(ticker, start_date, end_date)
-    
-    if isinstance(stock_data, str):  # If there was an error fetching data
-        return stock_data, None
-    
-    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)
-    
-    if isinstance(future_prices, str):  # If there was an error in prediction
-        return future_prices, None
-    
-    decision = "Buy" if future_prices[-1] > stock_data['Close'].iloc[-1] else "Sell"
-    
-    graph = plot_stock_data(ticker, start_date, end_date)
-    
-    if isinstance(graph, str):  # If there was an error in plotting
-        return graph, None
-    
-    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']
+    # Fetch historical data for the given ticker symbol
+    data = yf.download(ticker, start=start_date, end=end_date)
+    return data
 
-# Use Textbox for date input since Gradio doesn't have a Date component anymore
-with gr.Blocks() as demo:
-    ticker_input = gr.components.Dropdown(choices=ticker_list, label="Stock Ticker")
-    start_date_input = gr.components.Textbox(label="Start Date (YYYY-MM-DD)", placeholder="e.g. 2023-01-01")
-    end_date_input = gr.components.Textbox(label="End Date (YYYY-MM-DD)", placeholder="e.g. 2023-12-31")
-    
-    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]
-    )
+# Example usage
+# data = fetch_data("AAPL", "2023-01-01", "2023-10-01")
+from sklearn.preprocessing import MinMaxScaler
+import numpy as np
 
-demo.launch()
+def prepare_data(data):
+    # Preprocessing
+    scaler = MinMaxScaler(feature_range=(0, 1))
+    scaled_data = scaler.fit_transform(data['Close'].values.reshape(-1, 1))
+
+    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')
+    return model
+
+# Example usage
+# 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)
+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)
+
+    X_test = []
+    X_test.append(last_60_days_scaled)
+    X_test = np.array(X_test)
+    
+    predicted_price = model.predict(X_test)
+    predicted_price = scaler.inverse_transform(predicted_price)  # Reverse scaling
+    return predicted_price[0][0]
+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()
+
+    return {
+        "Predicted Price": predicted_price,
+        "Percentage Change": percentage_change,
+        "Highest Value": highest_value,
+        "Lowest Value": lowest_value,
+    }
+
+# UI setup
+stock_tickers = ["AAPL", "MSFT", "GOOGL", "AMZN", "TSLA", "FB", "NFLX", "NVDA", "INTC", "AMD"]
+
+gr.Interface(
+    fn=stock_prediction,
+    inputs=[
+        gr.Dropdown(choices=stock_tickers, label="Stock Ticker"),
+        gr.Date(label="Start Date"),
+        gr.Date(label="End Date"),
+    ],
+    outputs=["json"],
+).launch()
 import matplotlib.pyplot as plt
 
-def plot_stock_data(ticker, start_date, end_date):
-    # Existing code to fetch stock data and make predictions...
-    stock_data = fetch_data(ticker, start_date, end_date)
-    
-    # Assuming you have future_dates and future_prices from your model
-    future_dates = pd.date_range(end_date, periods=90, freq='D')  # Example for future dates
-    future_prices = model_predict(stock_data)  # Example for predicted prices
-    
-    # Check lengths of future_dates and future_prices
-    print(f"Length of future_dates: {len(future_dates)}")
-    print(f"Length of future_prices: {len(future_prices)}")
-
-    # Ensure they are the same length
-    min_length = min(len(future_dates), len(future_prices))
-    future_dates = future_dates[:min_length]
-    future_prices = future_prices[:min_length]
-
-    # Plot historical stock data
-    plt.figure(figsize=(10, 5))
-    plt.plot(stock_data.index, stock_data['Close'], label="Historical Prices")
-    
-    # Plot future predicted prices
-    plt.plot(future_dates, future_prices, label="Predicted Future Prices", linestyle='--')
-    
-    plt.xlabel("Date")
-    plt.ylabel("Stock Price")
-    plt.title(f"{ticker} Stock Price Prediction")
+def plot_graph(data, predicted_prices):
+    plt.figure(figsize=(14, 5))
+    plt.plot(data['Close'], label='Historical Prices', color='blue')
+    plt.plot(predicted_prices, label='Predicted Prices', color='red')
+    plt.title('Stock Price Prediction')
+    plt.xlabel('Date')
+    plt.ylabel('Stock Price')
     plt.legend()
-    plt.grid(True)
-    
     plt.show()
-    return plt.gcf()  # Return the current figure object
-    import matplotlib.pyplot as plt
-import pandas as pd
-
-def plot_stock_data(ticker, start_date, end_date):
-    # Fetch stock data and make predictions...
-    stock_data = fetch_data(ticker, start_date, end_date)
-    
-    # Example future dates (change this according to your actual future date range logic)
-    future_dates = pd.date_range(end_date, periods=90, freq='D')  # Generates 90 future dates
-    future_prices = model_predict(stock_data)  # Generates 89 future prices (example)
-
-    # Ensure both future_dates and future_prices have the same length
-    min_length = min(len(future_dates), len(future_prices))
-    future_dates = future_dates[:min_length]
-    future_prices = future_prices[:min_length]
-
-    # Plot historical stock data
-    plt.figure(figsize=(10, 5))
-    plt.plot(stock_data.index, stock_data['Close'], label="Historical Prices")
-
-    # Plot future predicted prices
-    plt.plot(future_dates, future_prices, label="Predicted Future Prices", linestyle='--')
-
-    # Add labels and title
-    plt.xlabel("Date")
-    plt.ylabel("Stock Price")
-    plt.title(f"{ticker} Stock Price Prediction")
-    plt.legend()
-    plt.grid(True)
-
-    # Show the plot
-    plt.show()
-    
-    return plt.gcf()  # Return the current figure object for Gradio to display
-    print(f"Future dates length: {len(future_dates)}")
-print(f"Future prices length: {len(future_prices)}")
-def plot_stock_data(ticker, start_date, end_date):
-    # Your existing code to fetch data and make predictions...
-
-    # Check lengths of future_dates and future_prices
-    print(f"Future dates length: {len(future_dates)}")
-    print(f"Future prices length: {len(future_prices)}")
-
-    # Ensure they match
-    if len(future_dates) != len(future_prices):
-        raise ValueError("The length of future_dates and future_prices must match.")
-
-    plt.plot(future_dates, future_prices, label="Predicted Future Prices")
-    # Additional plotting code...
-
 
+# Call this function in your `stock_prediction` function to plot the graph