Update app.py

app.py

@@ -1,164 +1,759 @@
 import gradio as gr
 import pandas as pd
 import numpy as np
-import yfinance as yf
 from datetime import datetime, timedelta
+from plotly.subplots import make_subplots
 import plotly.graph_objects as go
 from prophet import Prophet
-import joblib
+from statsmodels.tsa.arima.model import ARIMA
+from statsmodels.tsa.stattools import adfuller
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+import tensorflow as tf
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import LSTM, Dense, Dropout
+import warnings
+warnings.filterwarnings('ignore')
 
-# Load pre-trained model (Prophet as example)
-def load_model():
+np.random.seed(42)
+tf.random.set_seed(42)
+
+# ============================================================================
+# DATA LOADING
+# ============================================================================
+
+def load_stock_data():
+    """Load AAPL stock data from CSV file"""
+    try:
+        df = pd.read_csv('AAPL_stock_data.csv', parse_dates=['Date'])
+        df = df.sort_values('Date').reset_index(drop=True)
+        df['Returns'] = df['Close'].pct_change()
+        
+        print(f"Loaded {len(df)} records from AAPL_stock_data.csv")
+        print(f"Date Range: {df['Date'].min()} to {df['Date'].max()}")
+        return df
+    except Exception as e:
+        print(f"Error loading CSV: {e}")
+        raise Exception("Please upload AAPL_stock_data.csv file")
+
+# ============================================================================
+# METRICS CALCULATION
+# ============================================================================
+
+def calculate_metrics(y_true, y_pred):
+    """Calculate evaluation metrics"""
+    rmse = np.sqrt(mean_squared_error(y_true, y_pred))
+    mae = mean_absolute_error(y_true, y_pred)
+    mape = np.mean(np.abs((y_true - y_pred) / y_true)) * 100
+    r2 = r2_score(y_true, y_pred)
+    return rmse, mae, mape, r2
+
+# ============================================================================
+# STATIONARITY TEST
+# ============================================================================
+
+def test_stationarity(timeseries):
+    """Perform Augmented Dickey-Fuller test"""
+    result = adfuller(timeseries.dropna(), autolag='AIC')
+    return {
+        'statistic': result[0],
+        'pvalue': result[1],
+        'is_stationary': result[1] <= 0.05,
+        'critical_values': result[4]
+    }
+
+# ============================================================================
+# MODEL 1: ARIMA
+# ============================================================================
+
+def train_arima_model(data, order=(5,1,0)):
+    """Train ARIMA model"""
     try:
-        model = joblib.load('best_model.pkl')
+        print(f"Training ARIMA{order}...")
+        model = ARIMA(data, order=order)
+        fitted_model = model.fit()
+        print("ARIMA trained successfully")
+        return fitted_model
+    except Exception as e:
+        print(f"ARIMA Error: {e}")
+        return None
+
+# ============================================================================
+# MODEL 2: PROPHET
+# ============================================================================
+
+def train_prophet_model(df):
+    """Train Prophet model"""
+    try:
+        print("Training Prophet...")
+        prophet_df = pd.DataFrame({
+            'ds': df['Date'],
+            'y': df['Close'].values
+        })
+        
+        model = Prophet(
+            daily_seasonality=True,
+            yearly_seasonality=True,
+            weekly_seasonality=True,
+            changepoint_prior_scale=0.05,
+            seasonality_prior_scale=10.0
+        )
+        model.fit(prophet_df)
+        print("Prophet trained successfully")
         return model
-    except:
+    except Exception as e:
+        print(f"Prophet Error: {e}")
         return None
 
-def predict_stock_price(ticker, days_to_predict):
-    """
-    Main prediction function for Gradio interface
-    """
+# ============================================================================
+# MODEL 3: LSTM
+# ============================================================================
+
+def create_lstm_dataset(data, look_back=60):
+    """Create sequences for LSTM"""
+    X, y = [], []
+    for i in range(look_back, len(data)):
+        X.append(data[i-look_back:i, 0])
+        y.append(data[i, 0])
+    return np.array(X), np.array(y)
+
+def train_lstm_model(data, look_back=60, epochs=50):
+    """Train LSTM model"""
     try:
-        # Download recent data
-        end_date = datetime.now()
-        start_date = end_date - timedelta(days=365*2)
+        print("Training LSTM...")
         
-        stock_data = yf.download(ticker, start=start_date, end=end_date)
+        scaler = MinMaxScaler(feature_range=(0, 1))
+        scaled_data = scaler.fit_transform(data.reshape(-1, 1))
         
-        if stock_data.empty:
-            return None, "Invalid ticker symbol or no data available"
+        X, y = create_lstm_dataset(scaled_data, look_back)
+        X = X.reshape((X.shape[0], X.shape[1], 1))
         
-        # Prepare data for Prophet
-        df = pd.DataFrame()
-        df['ds'] = stock_data.index
-        df['y'] = stock_data['Close'].values
+        model = Sequential([
+            LSTM(50, return_sequences=True, input_shape=(look_back, 1)),
+            Dropout(0.2),
+            LSTM(50, return_sequences=False),
+            Dropout(0.2),
+            Dense(25, activation='relu'),
+            Dense(1)
+        ])
         
-        # Train Prophet model
-        model = Prophet(daily_seasonality=True, yearly_seasonality=True)
-        model.fit(df)
+        model.compile(optimizer='adam', loss='mean_squared_error')
+        model.fit(X, y, batch_size=32, epochs=epochs, verbose=0)
         
-        # Make predictions
-        future = model.make_future_dataframe(periods=int(days_to_predict))
-        forecast = model.predict(future)
+        print("LSTM trained successfully")
+        return model, scaler, look_back
+    except Exception as e:
+        print(f"LSTM Error: {e}")
+        return None, None, None
+
+# ============================================================================
+# EDA FUNCTION
+# ============================================================================
+
+def generate_eda():
+    """Generate exploratory data analysis"""
+    try:
+        df = load_stock_data()
         
-        # Create interactive plot
-        fig = go.Figure()
+        # Create subplots
+        fig = make_subplots(
+            rows=2, cols=2,
+            subplot_titles=('Stock Close Price Over Time', 'Trading Volume', 
+                          'Daily Returns', 'Returns Distribution'),
+            specs=[[{"secondary_y": False}, {"secondary_y": False}],
+                   [{"secondary_y": False}, {"secondary_y": False}]]
+        )
         
-        # Historical data
-        fig.add_trace(go.Scatter(
-            x=df['ds'],
-            y=df['y'],
-            mode='lines',
-            name='Historical Price',
-            line=dict(color='blue')
-        ))
+        # Close Price
+        fig.add_trace(
+            go.Scatter(x=df['Date'], y=df['Close'], mode='lines', 
+                      name='Close Price', line=dict(color='blue', width=1.5)),
+            row=1, col=1
+        )
         
-        # Predictions
-        future_dates = forecast['ds'][len(df):]
-        future_prices = forecast['yhat'][len(df):]
+        # Volume
+        fig.add_trace(
+            go.Bar(x=df['Date'], y=df['Volume'], name='Volume', 
+                  marker=dict(color='green', opacity=0.6)),
+            row=1, col=2
+        )
         
-        fig.add_trace(go.Scatter(
-            x=future_dates,
-            y=future_prices,
-            mode='lines',
-            name='Predicted Price',
-            line=dict(color='red', dash='dash')
-        ))
+        # Daily Returns
+        fig.add_trace(
+            go.Scatter(x=df['Date'], y=df['Returns'], mode='lines',
+                      name='Returns', line=dict(color='red', width=0.8)),
+            row=2, col=1
+        )
+        fig.add_hline(y=0, line_dash="dash", line_color="black", row=2, col=1)
         
-        # Confidence intervals
-        fig.add_trace(go.Scatter(
-            x=future_dates,
-            y=forecast['yhat_upper'][len(df):],
-            fill=None,
-            mode='lines',
-            line_color='rgba(255,0,0,0)',
-            showlegend=False
-        ))
+        # Returns Distribution
+        fig.add_trace(
+            go.Histogram(x=df['Returns'].dropna(), nbinsx=50, 
+                        name='Distribution', marker=dict(color='purple', opacity=0.7)),
+            row=2, col=2
+        )
+        
+        fig.update_layout(height=800, showlegend=False, template='plotly_white')
+        fig.update_xaxes(title_text="Date", row=1, col=1)
+        fig.update_xaxes(title_text="Date", row=1, col=2)
+        fig.update_xaxes(title_text="Date", row=2, col=1)
+        fig.update_xaxes(title_text="Returns", row=2, col=2)
+        fig.update_yaxes(title_text="Price ($)", row=1, col=1)
+        fig.update_yaxes(title_text="Volume", row=1, col=2)
+        fig.update_yaxes(title_text="Returns", row=2, col=1)
+        fig.update_yaxes(title_text="Frequency", row=2, col=2)
         
+        # Statistics
+        stats = f"""
+### 📊 Dataset Statistics
+
+**Price Statistics:**
+- Mean Close Price: ${df['Close'].mean():.2f}
+- Median Close Price: ${df['Close'].median():.2f}
+- Min Close Price: ${df['Close'].min():.2f}
+- Max Close Price: ${df['Close'].max():.2f}
+- Standard Deviation: ${df['Close'].std():.2f}
+
+**Returns Statistics:**
+- Mean Daily Return: {df['Returns'].mean()*100:.4f}%
+- Volatility (Std): {df['Returns'].std()*100:.4f}%
+- Min Return: {df['Returns'].min()*100:.2f}%
+- Max Return: {df['Returns'].max()*100:.2f}%
+
+**Dataset Info:**
+- Total Records: {len(df)}
+- Date Range: {df['Date'].min().strftime('%Y-%m-%d')} to {df['Date'].max().strftime('%Y-%m-%d')}
+- Missing Values: {df.isnull().sum().sum()}
+        """
+        
+        # Stationarity test
+        stationarity_result = test_stationarity(df['Close'])
+        
+        stationarity_text = f"""
+### 🔬 Stationarity Test (Augmented Dickey-Fuller)
+
+- **ADF Statistic:** {stationarity_result['statistic']:.6f}
+- **p-value:** {stationarity_result['pvalue']:.6f}
+- **Result:** {'✅ Series is STATIONARY' if stationarity_result['is_stationary'] else '❌ Series is NON-STATIONARY'}
+
+**Critical Values:**
+"""
+        for key, value in stationarity_result['critical_values'].items():
+            stationarity_text += f"- {key}: {value:.3f}\n"
+        
+        return fig, stats, stationarity_text
+        
+    except Exception as e:
+        error_msg = f"### ❌ Error\n\n{str(e)}"
+        return None, error_msg, error_msg
+
+# ============================================================================
+# ROLLING WINDOW EVALUATION
+# ============================================================================
+
+def rolling_window_evaluation(df, test_size=90):
+    """Perform rolling window evaluation for all models"""
+    
+    print("\n" + "="*70)
+    print("RUNNING MODEL EVALUATION")
+    print("="*70)
+    
+    train_data = df[:-test_size].copy()
+    test_data = df[-test_size:].copy()
+    
+    print(f"Training set: {len(train_data)} days")
+    print(f"Test set: {len(test_data)} days")
+    
+    results = {
+        'ARIMA': {'predictions': [], 'metrics': {}},
+        'LSTM': {'predictions': [], 'metrics': {}},
+        'Prophet': {'predictions': [], 'metrics': {}}
+    }
+    
+    # ARIMA
+    arima_model = train_arima_model(train_data['Close'].values)
+    if arima_model:
+        arima_forecast = arima_model.forecast(steps=test_size)
+        results['ARIMA']['predictions'] = arima_forecast
+        rmse, mae, mape, r2 = calculate_metrics(test_data['Close'].values, arima_forecast)
+        results['ARIMA']['metrics'] = {'RMSE': rmse, 'MAE': mae, 'MAPE': mape, 'R2': r2}
+        print(f"ARIMA - RMSE: {rmse:.2f}, MAE: {mae:.2f}, MAPE: {mape:.2f}%, R2: {r2:.4f}")
+    
+    # Prophet
+    prophet_model = train_prophet_model(train_data)
+    if prophet_model:
+        future = prophet_model.make_future_dataframe(periods=test_size)
+        forecast = prophet_model.predict(future)
+        prophet_forecast = forecast['yhat'].iloc[-test_size:].values
+        results['Prophet']['predictions'] = prophet_forecast
+        rmse, mae, mape, r2 = calculate_metrics(test_data['Close'].values, prophet_forecast)
+        results['Prophet']['metrics'] = {'RMSE': rmse, 'MAE': mae, 'MAPE': mape, 'R2': r2}
+        print(f"Prophet - RMSE: {rmse:.2f}, MAE: {mae:.2f}, MAPE: {mape:.2f}%, R2: {r2:.4f}")
+    
+    # LSTM
+    lstm_model, scaler, look_back = train_lstm_model(train_data['Close'].values, epochs=50)
+    if lstm_model and scaler:
+        all_data = df['Close'].values
+        test_inputs = all_data[len(train_data) - look_back:]
+        test_inputs = scaler.transform(test_inputs.reshape(-1, 1))
+        
+        X_test = []
+        for i in range(look_back, len(test_inputs)):
+            X_test.append(test_inputs[i-look_back:i, 0])
+        X_test = np.array(X_test)
+        X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))
+        
+        lstm_predictions = lstm_model.predict(X_test, verbose=0)
+        lstm_predictions = scaler.inverse_transform(lstm_predictions)
+        results['LSTM']['predictions'] = lstm_predictions.flatten()
+        
+        rmse, mae, mape, r2 = calculate_metrics(test_data['Close'].values, lstm_predictions.flatten())
+        results['LSTM']['metrics'] = {'RMSE': rmse, 'MAE': mae, 'MAPE': mape, 'R2': r2}
+        print(f"LSTM - RMSE: {rmse:.2f}, MAE: {mae:.2f}, MAPE: {mape:.2f}%, R2: {r2:.4f}")
+    
+    print("="*70 + "\n")
+    return results, train_data, test_data
+
+# ============================================================================
+# FUTURE PREDICTIONS
+# ============================================================================
+
+def predict_future(df, days_to_predict=30):
+    """Make future predictions with all three models"""
+    
+    print("\n" + "="*70)
+    print(f"GENERATING {days_to_predict}-DAY PREDICTIONS")
+    print("="*70)
+    
+    full_data = df['Close'].values
+    predictions = {}
+    
+    # ARIMA
+    arima_model = train_arima_model(full_data)
+    if arima_model:
+        arima_forecast = arima_model.forecast(steps=days_to_predict)
+        predictions['ARIMA'] = arima_forecast
+    
+    # Prophet
+    prophet_model = train_prophet_model(df)
+    if prophet_model:
+        future = prophet_model.make_future_dataframe(periods=days_to_predict)
+        forecast = prophet_model.predict(future)
+        predictions['Prophet'] = forecast['yhat'].iloc[-days_to_predict:].values
+    
+    # LSTM
+    lstm_model, scaler, look_back = train_lstm_model(full_data, epochs=50)
+    if lstm_model and scaler:
+        last_sequence = scaler.transform(full_data[-look_back:].reshape(-1, 1))
+        lstm_predictions = []
+        
+        for _ in range(days_to_predict):
+            X_test = last_sequence.reshape((1, look_back, 1))
+            pred = lstm_model.predict(X_test, verbose=0)
+            lstm_predictions.append(pred[0, 0])
+            last_sequence = np.append(last_sequence[1:], pred).reshape(-1, 1)
+        
+        lstm_predictions = scaler.inverse_transform(np.array(lstm_predictions).reshape(-1, 1))
+        predictions['LSTM'] = lstm_predictions.flatten()
+    
+    print("="*70 + "\n")
+    return predictions
+
+# ============================================================================
+# VISUALIZATION FUNCTIONS
+# ============================================================================
+
+def create_comparison_plot(results, train_data, test_data):
+    """Create comparison plot for model evaluation"""
+    fig = go.Figure()
+    
+    fig.add_trace(go.Scatter(
+        x=train_data['Date'],
+        y=train_data['Close'],
+        mode='lines',
+        name='Training Data',
+        line=dict(color='blue', width=1.5)
+    ))
+    
+    fig.add_trace(go.Scatter(
+        x=test_data['Date'],
+        y=test_data['Close'],
+        mode='lines',
+        name='Actual Test Data',
+        line=dict(color='green', width=3)
+    ))
+    
+    colors = {'ARIMA': 'red', 'LSTM': 'orange', 'Prophet': 'purple'}
+    
+    for model_name in ['ARIMA', 'LSTM', 'Prophet']:
+        if len(results[model_name]['predictions']) > 0:
+            fig.add_trace(go.Scatter(
+                x=test_data['Date'],
+                y=results[model_name]['predictions'],
+                mode='lines',
+                name=f'{model_name} Prediction',
+                line=dict(color=colors[model_name], dash='dash', width=2)
+            ))
+    
+    fig.update_layout(
+        title='AAPL Stock Price - Model Comparison (Rolling Window Evaluation)',
+        xaxis_title='Date',
+        yaxis_title='Stock Price ($)',
+        hovermode='x unified',
+        height=600,
+        template='plotly_white',
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1)
+    )
+    
+    return fig
+
+def create_future_plot(df, predictions, days_to_predict):
+    """Create plot for future predictions"""
+    fig = go.Figure()
+    
+    recent_data = df.tail(180)
+    fig.add_trace(go.Scatter(
+        x=recent_data['Date'],
+        y=recent_data['Close'],
+        mode='lines',
+        name='Historical Data',
+        line=dict(color='blue', width=2)
+    ))
+    
+    last_date = df['Date'].iloc[-1]
+    future_dates = pd.date_range(start=last_date + timedelta(days=1), periods=days_to_predict)
+    
+    colors = {'ARIMA': 'red', 'LSTM': 'orange', 'Prophet': 'purple'}
+    
+    for model_name, preds in predictions.items():
         fig.add_trace(go.Scatter(
             x=future_dates,
-            y=forecast['yhat_lower'][len(df):],
-            fill='tonexty',
-            mode='lines',
-            line_color='rgba(255,0,0,0)',
-            name='Confidence Interval',
-            fillcolor='rgba(255,0,0,0.2)'
+            y=preds,
+            mode='lines+markers',
+            name=f'{model_name} Forecast',
+            line=dict(color=colors[model_name], dash='dash', width=2),
+            marker=dict(size=4)
         ))
+    
+    fig.update_layout(
+        title=f'AAPL Stock Price Forecast - Next {days_to_predict} Days',
+        xaxis_title='Date',
+        yaxis_title='Stock Price ($)',
+        hovermode='x unified',
+        height=600,
+        template='plotly_white',
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1)
+    )
+    
+    return fig
+
+# ============================================================================
+# FORMATTING FUNCTIONS
+# ============================================================================
+
+def format_metrics_table(results):
+    """Format metrics as markdown table"""
+    table = "### 📊 Model Performance Comparison\n\n"
+    table += "| Model | RMSE | MAE | MAPE (%) | R² Score |\n"
+    table += "|-------|------|-----|----------|----------|\n"
+    
+    for model_name in ['ARIMA', 'LSTM', 'Prophet']:
+        metrics = results[model_name]['metrics']
+        if metrics:
+            table += f"| **{model_name}** | {metrics['RMSE']:.2f} | {metrics['MAE']:.2f} | {metrics['MAPE']:.2f} | {metrics['R2']:.4f} |\n"
+    
+    best_model = min(
+        results.keys(), 
+        key=lambda x: results[x]['metrics'].get('RMSE', float('inf')) if results[x]['metrics'] else float('inf')
+    )
+    
+    table += f"\n### 🏆 Best Model: **{best_model}** (Lowest RMSE)\n\n"
+    
+    table += "#### Model Characteristics:\n\n"
+    table += "- **ARIMA**: Statistical model, captures linear trends and autocorrelation\n"
+    table += "- **LSTM**: Deep learning model, captures complex non-linear patterns\n"
+    table += "- **Prophet**: Hybrid model, robust to missing data and seasonality\n\n"
+    
+    table += "#### Evaluation Metrics:\n\n"
+    table += "- **RMSE** (Root Mean Squared Error): Lower is better, penalizes large errors\n"
+    table += "- **MAE** (Mean Absolute Error): Average prediction error in dollars\n"
+    table += "- **MAPE** (Mean Absolute Percentage Error): Prediction error as percentage\n"
+    table += "- **R²** (R-squared): Proportion of variance explained (closer to 1 is better)\n"
+    
+    return table
+
+def format_prediction_summary(df, predictions, days_to_predict):
+    """Format prediction summary"""
+    current_price = df['Close'].iloc[-1]
+    current_date = df['Date'].iloc[-1].strftime('%Y-%m-%d')
+    
+    summary = f"### 📈 AAPL Stock Price Predictions ({days_to_predict} days ahead)\n\n"
+    summary += f"**Current Price** (as of {current_date}): **${current_price:.2f}**\n\n"
+    summary += "| Model | Predicted Price | Change ($) | Change (%) |\n"
+    summary += "|-------|----------------|------------|------------|\n"
+    
+    for model_name, preds in predictions.items():
+        pred_price = preds[-1]
+        change = pred_price - current_price
+        pct_change = (change / current_price) * 100
         
-        fig.update_layout(
-            title=f'{ticker} Stock Price Prediction',
-            xaxis_title='Date',
-            yaxis_title='Price ($)',
-            hovermode='x unified'
-        )
+        emoji = "📈" if change > 0 else "📉"
+        summary += f"| **{model_name}** {emoji} | ${pred_price:.2f} | ${change:+.2f} | {pct_change:+.2f}% |\n"
+    
+    avg_prediction = np.mean([preds[-1] for preds in predictions.values()])
+    avg_change = avg_prediction - current_price
+    avg_pct_change = (avg_change / current_price) * 100
+    
+    summary += f"\n**Average Prediction**: ${avg_prediction:.2f} ({avg_pct_change:+.2f}%)\n\n"
+    
+    summary += "#### ⚠️ Disclaimer\n"
+    summary += "*These predictions are for educational purposes only. Stock market predictions are inherently uncertain. "
+    summary += "Past performance does not guarantee future results. Always consult with financial advisors before making investment decisions.*\n"
+    
+    return summary
+
+# ============================================================================
+# MAIN INTERFACE FUNCTIONS
+# ============================================================================
+
+def run_evaluation():
+    """Run model evaluation"""
+    try:
+        df = load_stock_data()
+        results, train_data, test_data = rolling_window_evaluation(df, test_size=90)
         
-        # Prepare summary statistics
-        last_price = df['y'].iloc[-1]
-        predicted_price = future_prices.iloc[-1]
-        price_change = predicted_price - last_price
-        percent_change = (price_change / last_price) * 100
-        
-        summary = f"""
-        ### Prediction Summary
-        - **Current Price**: ${last_price:.2f}
-        - **Predicted Price ({days_to_predict} days)**: ${predicted_price:.2f}
-        - **Expected Change**: ${price_change:.2f} ({percent_change:+.2f}%)
-        - **Prediction Date**: {future_dates.iloc[-1].strftime('%Y-%m-%d')}
-        """
+        plot = create_comparison_plot(results, train_data, test_data)
+        metrics_table = format_metrics_table(results)
         
-        return fig, summary
+        return plot, metrics_table
+    except Exception as e:
+        error_msg = f"### ❌ Error\n\n{str(e)}\n\nPlease make sure AAPL_stock_data.csv is uploaded."
+        return None, error_msg
+
+def run_prediction(days_to_predict):
+    """Run future prediction"""
+    try:
+        df = load_stock_data()
+        predictions = predict_future(df, int(days_to_predict))
         
+        plot = create_future_plot(df, predictions, int(days_to_predict))
+        summary = format_prediction_summary(df, predictions, int(days_to_predict))
+        
+        return plot, summary
     except Exception as e:
-        return None, f"Error: {str(e)}"
+        error_msg = f"### ❌ Error\n\n{str(e)}\n\nPlease make sure AAPL_stock_data.csv is uploaded."
+        return None, error_msg
+
+# ============================================================================
+# GRADIO INTERFACE
+# ============================================================================
 
-# Create Gradio interface
-with gr.Blocks(title="Stock Price Forecasting - DataSynthis_ML_JobTask") as demo:
+custom_css = """
+.gradio-container {
+    font-family: 'Arial', sans-serif;
+}
+.main-header {
+    text-align: center;
+    padding: 20px;
+    background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    border-radius: 10px;
+    margin-bottom: 20px;
+}
+"""
+
+with gr.Blocks(title="Stock Price Forecasting - DataSynthis_ML_JobTask", theme=gr.themes.Soft(), css=custom_css) as demo:
+    
+    gr.Markdown("""
+    <div class="main-header">
+        <h1>📈 AAPL Stock Price Time-Series Forecasting</h1>
+        <h3>DataSynthis ML Job Task - SET B</h3>
+    </div>
+    """)
+    
     gr.Markdown("""
-    # 📈 Stock Price Time-Series Forecasting
-    ### DataSynthis ML Job Task - SET B
+    This application implements and compares **three time-series forecasting models** for Apple Inc. (AAPL) stock price prediction:
     
-    This application uses advanced time-series forecasting models to predict future stock prices.
-    Enter a stock ticker symbol and the number of days to predict.
+    - 🔴 **ARIMA** (AutoRegressive Integrated Moving Average) - Traditional statistical model
+    - 🟠 **LSTM** (Long Short-Term Memory) - Deep learning neural network
+    - 🟣 **Prophet** - Facebook's robust forecasting tool
+    
+    ---
     """)
     
-    with gr.Row():
-        with gr.Column(scale=1):
-            ticker_input = gr.Textbox(
-                label="Stock Ticker Symbol",
-                placeholder="e.g., AAPL, GOOGL, MSFT",
-                value="AAPL"
+    with gr.Tabs() as tabs:
+        
+        # TAB 1: Exploratory Data Analysis
+        with gr.Tab("📊 Exploratory Data Analysis"):
+            gr.Markdown("""
+            ### Dataset Overview & Statistical Analysis
+            
+            Explore the AAPL stock price data with comprehensive visualizations and statistical summaries.
+            """)
+            
+            eda_btn = gr.Button("🔍 Generate EDA Report", variant="primary", size="lg")
+            
+            eda_plot = gr.Plot(label="EDA Visualizations")
+            
+            with gr.Row():
+                with gr.Column():
+                    eda_stats = gr.Markdown()
+                with gr.Column():
+                    eda_stationarity = gr.Markdown()
+            
+            eda_btn.click(
+                fn=generate_eda,
+                inputs=[],
+                outputs=[eda_plot, eda_stats, eda_stationarity]
             )
-            days_input = gr.Slider(
-                minimum=1,
-                maximum=90,
-                value=30,
-                step=1,
-                label="Days to Predict"
+        
+        # TAB 2: Future Prediction
+        with gr.Tab("🔮 Future Prediction"):
+            gr.Markdown("""
+            ### Predict Future Stock Prices
+            Select the number of days you want to predict and click **Generate Predictions** to see forecasts from all three models.
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    days_slider = gr.Slider(
+                        minimum=7,
+                        maximum=90,
+                        value=30,
+                        step=1,
+                        label="📅 Days to Predict",
+                        info="Choose between 7 and 90 days"
+                    )
+                    predict_btn = gr.Button("🚀 Generate Predictions", variant="primary", size="lg")
+                    
+                    gr.Markdown("#### Quick Options:")
+                    
+                    with gr.Row():
+                        btn_7 = gr.Button("1 Week", size="sm")
+                        btn_30 = gr.Button("1 Month", size="sm")
+                        btn_60 = gr.Button("2 Months", size="sm")
+                        btn_90 = gr.Button("3 Months", size="sm")
+                    
+                    btn_7.click(lambda: 7, outputs=days_slider)
+                    btn_30.click(lambda: 30, outputs=days_slider)
+                    btn_60.click(lambda: 60, outputs=days_slider)
+                    btn_90.click(lambda: 90, outputs=days_slider)
+            
+            prediction_plot = gr.Plot(label="📊 Forecast Chart")
+            prediction_summary = gr.Markdown()
+            
+            predict_btn.click(
+                fn=run_prediction,
+                inputs=[days_slider],
+                outputs=[prediction_plot, prediction_summary]
             )
-            predict_btn = gr.Button("🔮 Predict", variant="primary")
+        
+        # TAB 3: Model Evaluation
+        with gr.Tab("📊 Model Evaluation"):
+            gr.Markdown("""
+            ### Rolling Window Evaluation
             
-        with gr.Column(scale=2):
-            output_plot = gr.Plot(label="Price Prediction Chart")
-            output_summary = gr.Markdown(label="Prediction Summary")
-    
-    predict_btn.click(
-        fn=predict_stock_price,
-        inputs=[ticker_input, days_input],
-        outputs=[output_plot, output_summary]
-    )
+            This evaluation uses the **last 90 days** as test data to compare model performance.
+            
+            **Evaluation Metrics:**
+            - **RMSE**: Root Mean Squared Error (lower is better)
+            - **MAE**: Mean Absolute Error (lower is better)
+            - **MAPE**: Mean Absolute Percentage Error (lower is better)
+            - **R²**: R-squared score (closer to 1 is better)
+            
+            Click the button below to run the evaluation:
+            """)
+            
+            eval_btn = gr.Button("🔬 Run Evaluation", variant="primary", size="lg")
+            
+            evaluation_plot = gr.Plot(label="📊 Model Comparison Chart")
+            metrics_output = gr.Markdown()
+            
+            eval_btn.click(
+                fn=run_evaluation,
+                inputs=[],
+                outputs=[evaluation_plot, metrics_output]
+            )
+        
+              # TAB 3: About
+        with gr.Tab("ℹ️ About"):
+            gr.Markdown("""
+            ## 📝 Project Information
+            
+            ### Models Implemented
+            
+            #### 1️⃣ ARIMA (5,1,0)
+            - **Type**: Statistical time-series model
+            - **Strengths**: Fast, interpretable, good for linear trends
+            - **Use Case**: Short-term predictions, linear patterns
+            - **Training Time**: < 1 second
+            
+            #### 2️⃣ LSTM Neural Network
+            - **Type**: Deep learning recurrent neural network
+            - **Architecture**: 2 LSTM layers (50 units each) with dropout
+            - **Strengths**: Captures complex non-linear patterns
+            - **Use Case**: Medium to long-term predictions
+            - **Training Time**: ~30-60 seconds
+            
+            #### 3️⃣ Prophet
+            - **Type**: Additive regression model by Facebook
+            - **Strengths**: Handles seasonality, robust to missing data
+            - **Use Case**: Business forecasting, interpretable components
+            - **Training Time**: ~5-10 seconds
+            
+            ---
+            
+            ### Dataset Information
+            - **Stock**: Apple Inc. (AAPL)
+            - **Features**: Date, Open, High, Low, Close, Volume
+            - **Target Variable**: Close Price
+            - **Data Source**: Historical stock data (CSV)
+            
+            ---
+            
+            ### Technical Stack
+            - **Framework**: Gradio 4.44.0
+            - **Deep Learning**: TensorFlow 2.15.0 / Keras
+            - **Statistical Models**: Statsmodels 0.14.0
+            - **Forecasting**: Prophet 1.1.5
+            - **Data Processing**: Pandas, NumPy, Scikit-learn
+            - **Visualization**: Plotly
+            
+            ---
+            
+            ### Deployment
+            - **Platform**: Hugging Face Spaces
+            - **Space Name**: DataSynthis_ML_JobTask
+            
+            
+      
+            
+            ---
+            
+            ### 👨‍💻 Author
+            **Md. Sadat Ahmed Rafi**  
+            Task: Time-Series Forecasting – Stock Prices
+          
+            
+            ---
+            
+            ### 📄 License
+            This project is created for the DataSynthis ML Job Task evaluation.
+            
+            """)
     
     gr.Markdown("""
     ---
-    ### Model Information
-    - **Models Implemented**: ARIMA, LSTM, Prophet
-    - **Evaluation Metrics**: RMSE, MAE, MAPE
-    - **Deployment**: Hugging Face Spaces
-    
-    ### About
-    This project implements and compares multiple time-series forecasting approaches for stock price prediction.
-    The deployed model uses Prophet for its robustness and ability to handle seasonal patterns.
+    <div style="text-align: center; color: #666; padding: 20px;">
+        <p><strong>DataSynthis ML Job Task - SET B</strong></p>
+        <p>Time-Series Forecasting – Stock Prices</p>
+        <p>Deployed on Hugging Face Spaces | Powered by Gradio</p>
+    </div>
     """)
 
+# ============================================================================
+# LAUNCH
+# ============================================================================
+
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()