Upload 7 files

README.md

@@ -0,0 +1,34 @@
+---
+title: Stock Price Forecasting
+emoji: 📈
+colorFrom: blue
+colorTo: green
+sdk: gradio
+sdk_version: 4.16.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Stock Price Forecasting App
+
+This application uses three different models (ARIMA, Prophet, and LSTM) to forecast stock prices.
+
+## Features
+- Real-time stock data fetching from Yahoo Finance
+- Multiple forecasting models
+- Interactive visualizations
+- Customizable forecast periods
+
+## Models
+1. **ARIMA** - Traditional statistical model
+2. **Prophet** - Facebook's time series forecasting
+3. **LSTM** - Deep learning neural network
+
+## Usage
+1. Enter a stock ticker symbol (e.g., AAPL, GOOGL)
+2. Select forecast period (1-90 days)
+3. Choose which model(s) to use
+4. Click "Generate Forecast"
+
+⚠️ **Disclaimer**: For educational purposes only. Not financial advice.

app.py

@@ -0,0 +1,325 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import pickle
+import yfinance as yf
+from statsmodels.tsa.arima.model import ARIMA
+from prophet import Prophet
+from tensorflow import keras
+from sklearn.preprocessing import MinMaxScaler
+import warnings
+warnings.filterwarnings('ignore')
+
+# Load your saved models (update paths as needed)
+# For Hugging Face, these will be in the same directory as app.py
+def load_models():
+    """Load all three models"""
+    try:
+        # Load ARIMA model
+        with open('arima_model.pkl', 'rb') as f:
+            arima_model = pickle.load(f)
+        
+        # Load Prophet model
+        with open('prophet_model.pkl', 'rb') as f:
+            prophet_model = pickle.load(f)
+        
+        # Load LSTM model and scaler
+        lstm_model = keras.models.load_model('lstm_model.h5')
+        with open('lstm_scaler.pkl', 'rb') as f:
+            scaler = pickle.load(f)
+        
+        return arima_model, prophet_model, lstm_model, scaler
+    except Exception as e:
+        print(f"Error loading models: {e}")
+        return None, None, None, None
+
+# Global variables for models
+arima_model, prophet_model, lstm_model, scaler = load_models()
+SEQ_LENGTH = 60  # Should match your training
+
+def fetch_stock_data(ticker, days=365):
+    """Fetch stock data from Yahoo Finance"""
+    try:
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=days)
+        df = yf.download(ticker, start=start_date, end=end_date, progress=False)
+        if df.empty:
+            return None, f"No data found for ticker: {ticker}"
+        df = df[['Close']].copy()
+        df.columns = ['Price']
+        return df, None
+    except Exception as e:
+        return None, str(e)
+
+def make_arima_forecast(data, days):
+    """Make ARIMA forecast"""
+    try:
+        # Retrain ARIMA with recent data (or use loaded model)
+        model = ARIMA(data['Price'], order=(1, 1, 1))
+        fitted = model.fit()
+        forecast = fitted.forecast(steps=days)
+        return forecast.values
+    except Exception as e:
+        print(f"ARIMA Error: {e}")
+        return None
+
+def make_prophet_forecast(data, days):
+    """Make Prophet forecast"""
+    try:
+        # Prepare data for Prophet
+        prophet_data = pd.DataFrame({
+            'ds': data.index,
+            'y': data['Price'].values
+        })
+        
+        # Create and fit model
+        model = Prophet(
+            daily_seasonality=True,
+            weekly_seasonality=True,
+            yearly_seasonality=True,
+            changepoint_prior_scale=0.05
+        )
+        model.fit(prophet_data)
+        
+        # Make forecast
+        future = model.make_future_dataframe(periods=days)
+        forecast = model.predict(future)
+        return forecast['yhat'].tail(days).values
+    except Exception as e:
+        print(f"Prophet Error: {e}")
+        return None
+
+def make_lstm_forecast(data, days, model, scaler, seq_length=60):
+    """Make LSTM forecast"""
+    try:
+        # Scale the data
+        scaled_data = scaler.transform(data[['Price']])
+        
+        # Prepare the last sequence
+        last_sequence = scaled_data[-seq_length:].reshape(1, seq_length, 1)
+        
+        predictions = []
+        current_sequence = last_sequence.copy()
+        
+        # Generate predictions day by day
+        for _ in range(days):
+            pred = model.predict(current_sequence, verbose=0)
+            predictions.append(pred[0, 0])
+            
+            # Update sequence
+            current_sequence = np.append(current_sequence[:, 1:, :], 
+                                        pred.reshape(1, 1, 1), axis=1)
+        
+        # Inverse transform predictions
+        predictions = scaler.inverse_transform(np.array(predictions).reshape(-1, 1))
+        return predictions.flatten()
+    except Exception as e:
+        print(f"LSTM Error: {e}")
+        return None
+
+def create_forecast_plot(historical_data, forecasts, ticker, model_names):
+    """Create interactive plotly chart"""
+    fig = go.Figure()
+    
+    # Historical data
+    fig.add_trace(go.Scatter(
+        x=historical_data.index,
+        y=historical_data['Price'],
+        mode='lines',
+        name='Historical Price',
+        line=dict(color='blue', width=2)
+    ))
+    
+    # Generate future dates
+    last_date = historical_data.index[-1]
+    future_dates = pd.date_range(start=last_date + timedelta(days=1), 
+                                  periods=len(forecasts[0]))
+    
+    # Plot forecasts
+    colors = ['red', 'purple', 'orange']
+    for i, (forecast, name) in enumerate(zip(forecasts, model_names)):
+        if forecast is not None:
+            fig.add_trace(go.Scatter(
+                x=future_dates,
+                y=forecast,
+                mode='lines+markers',
+                name=f'{name} Forecast',
+                line=dict(color=colors[i], width=2, dash='dash'),
+                marker=dict(size=6)
+            ))
+    
+    fig.update_layout(
+        title=f'{ticker} Stock Price Forecast',
+        xaxis_title='Date',
+        yaxis_title='Price ($)',
+        hovermode='x unified',
+        template='plotly_white',
+        height=600,
+        showlegend=True,
+        legend=dict(
+            yanchor="top",
+            y=0.99,
+            xanchor="left",
+            x=0.01
+        )
+    )
+    
+    return fig
+
+def predict_stock(ticker, forecast_days, model_choice):
+    """Main prediction function"""
+    # Validate inputs
+    if not ticker:
+        return None, "Please enter a stock ticker symbol", None
+    
+    ticker = ticker.upper().strip()
+    
+    # Fetch data
+    data, error = fetch_stock_data(ticker, days=730)  # 2 years of data
+    if error:
+        return None, f"Error: {error}", None
+    
+    # Make forecasts based on model choice
+    forecasts = []
+    model_names = []
+    
+    if model_choice in ["All Models", "ARIMA"]:
+        arima_forecast = make_arima_forecast(data, forecast_days)
+        if arima_forecast is not None:
+            forecasts.append(arima_forecast)
+            model_names.append("ARIMA")
+    
+    if model_choice in ["All Models", "Prophet"]:
+        prophet_forecast = make_prophet_forecast(data, forecast_days)
+        if prophet_forecast is not None:
+            forecasts.append(prophet_forecast)
+            model_names.append("Prophet")
+    
+    if model_choice in ["All Models", "LSTM"] and lstm_model is not None:
+        lstm_forecast = make_lstm_forecast(data, forecast_days, lstm_model, scaler, SEQ_LENGTH)
+        if lstm_forecast is not None:
+            forecasts.append(lstm_forecast)
+            model_names.append("LSTM")
+    
+    if not forecasts:
+        return None, "Failed to generate forecasts. Please try again.", None
+    
+    # Create plot
+    fig = create_forecast_plot(data, forecasts, ticker, model_names)
+    
+    # Create forecast table
+    future_dates = pd.date_range(
+        start=data.index[-1] + timedelta(days=1), 
+        periods=forecast_days
+    )
+    
+    forecast_df = pd.DataFrame({'Date': future_dates.strftime('%Y-%m-%d')})
+    for forecast, name in zip(forecasts, model_names):
+        forecast_df[f'{name} Prediction ($)'] = np.round(forecast, 2)
+    
+    # Summary statistics
+    summary = f"""
+    📊 **Forecast Summary for {ticker}**
+    
+    - Current Price: ${data['Price'].iloc[-1]:.2f}
+    - Forecast Period: {forecast_days} days
+    - Models Used: {', '.join(model_names)}
+    
+    **Predicted Price Range (Day {forecast_days}):**
+    """
+    
+    for forecast, name in zip(forecasts, model_names):
+        final_price = forecast[-1]
+        change = ((final_price - data['Price'].iloc[-1]) / data['Price'].iloc[-1]) * 100
+        summary += f"\n- {name}: ${final_price:.2f} ({change:+.2f}%)"
+    
+    return fig, summary, forecast_df
+
+# Create Gradio Interface
+with gr.Blocks(title="Stock Price Forecasting", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 📈 Stock Price Forecasting App
+        
+        Predict future stock prices using ARIMA, Prophet, and LSTM models.
+        Enter a stock ticker symbol and select forecast parameters below.
+        
+        **Note:** Predictions are for educational purposes only. Not financial advice.
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            ticker_input = gr.Textbox(
+                label="Stock Ticker Symbol",
+                placeholder="e.g., AAPL, GOOGL, TSLA",
+                value="AAPL"
+            )
+            
+            forecast_days = gr.Slider(
+                minimum=1,
+                maximum=90,
+                value=30,
+                step=1,
+                label="Forecast Days"
+            )
+            
+            model_choice = gr.Radio(
+                choices=["All Models", "ARIMA", "Prophet", "LSTM"],
+                value="All Models",
+                label="Select Model(s)"
+            )
+            
+            predict_btn = gr.Button("🔮 Generate Forecast", variant="primary", size="lg")
+        
+        with gr.Column(scale=2):
+            output_plot = gr.Plot(label="Forecast Visualization")
+    
+    with gr.Row():
+        output_summary = gr.Markdown(label="Forecast Summary")
+    
+    with gr.Row():
+        output_table = gr.Dataframe(
+            label="Detailed Forecast",
+            wrap=True,
+            interactive=False
+        )
+    
+    # Examples
+    gr.Examples(
+        examples=[
+            ["AAPL", 30, "All Models"],
+            ["GOOGL", 14, "Prophet"],
+            ["TSLA", 60, "LSTM"],
+            ["MSFT", 45, "ARIMA"],
+        ],
+        inputs=[ticker_input, forecast_days, model_choice],
+    )
+    
+    # Connect the button to the function
+    predict_btn.click(
+        fn=predict_stock,
+        inputs=[ticker_input, forecast_days, model_choice],
+        outputs=[output_plot, output_summary, output_table]
+    )
+    
+    gr.Markdown(
+        """
+        ---
+        ### 📚 About the Models
+        
+        - **ARIMA**: Statistical model for time series forecasting
+        - **Prophet**: Facebook's forecasting tool, excellent for seasonality
+        - **LSTM**: Deep learning model that captures complex patterns
+        
+        ### ⚠️ Disclaimer
+        This tool is for educational and research purposes only. Stock market predictions are inherently uncertain. 
+        Always conduct thorough research and consult with financial advisors before making investment decisions.
+        """
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()

arima_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f03d08049cdf6937a0c1bd79933cdb5822a144f05313ed980e5578c5a8dff1e7
+size 2287121

lstm_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04df565ab23e73b8b8af3f36f94cabe79c0867dfa9afe427c4e59fb446744583
+size 426896

lstm_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cef5a6476cc98fe5a756665fb1917a7f3a602e72b0c46c317466f29013fb27a7
+size 616

prophet_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff674ae41051bc6246ea30276ccf3671b986f7dc039c078141c1de2b61801649
+size 98483

requirements.txt

@@ -0,0 +1,9 @@
+gradio==4.16.0
+pandas==2.1.4
+numpy==1.26.3
+plotly==5.18.0
+yfinance==0.2.35
+statsmodels==0.14.1
+prophet==1.1.5
+tensorflow==2.15.0
+scikit-learn==1.3.2