Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import pandas as pd | |
| import numpy as np | |
| from datetime import datetime, timedelta | |
| from plotly.subplots import make_subplots | |
| import plotly.graph_objects as go | |
| from prophet.serialize import model_from_json | |
| 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, load_model | |
| from tensorflow.keras.layers import LSTM, Dense, Dropout | |
| import pickle | |
| import warnings | |
| warnings.filterwarnings('ignore') | |
| 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 load_arima_model(): | |
| """Load pre-trained ARIMA model""" | |
| try: | |
| with open('models/arima_model.pkl', 'rb') as f: | |
| model = pickle.load(f) | |
| print("ARIMA model loaded successfully") | |
| return model | |
| except Exception as e: | |
| print(f"ARIMA Load Error: {e}") | |
| return None | |
| # ============================================================================ | |
| # MODEL 2: PROPHET | |
| # ============================================================================ | |
| def load_prophet_model(): | |
| """Load pre-trained Prophet model""" | |
| try: | |
| # Load the model from JSON | |
| with open('models/prophet_model.json', 'r') as f: | |
| model = model_from_json(f.read()) | |
| print("Prophet model loaded successfully") | |
| return model | |
| except Exception as e: | |
| print(f"Prophet Load Error: {e}") | |
| return None | |
| # ============================================================================ | |
| # MODEL 3: LSTM | |
| # ============================================================================ | |
| def load_lstm_model(): | |
| """Load pre-trained LSTM model and scaler""" | |
| try: | |
| # Load the model | |
| lstm_model = load_model('models/lstm_model.h5') | |
| # Load the scaler | |
| with open('models/lstm_scaler.pkl', 'rb') as f: | |
| scaler = pickle.load(f) | |
| print("LSTM model and scaler loaded successfully") | |
| return lstm_model, scaler | |
| except Exception as e: | |
| print(f"LSTM Load Error: {e}") | |
| return None, None | |
| # ============================================================================ | |
| # EDA FUNCTION | |
| # ============================================================================ | |
| def generate_eda(): | |
| """Generate exploratory data analysis""" | |
| try: | |
| df = load_stock_data() | |
| # 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}]] | |
| ) | |
| # 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 | |
| ) | |
| # 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 | |
| ) | |
| # 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) | |
| # 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 = load_arima_model() | |
| 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 = load_prophet_model() | |
| 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 = load_lstm_model() | |
| if lstm_model and scaler: | |
| all_data = df['Close'].values | |
| test_inputs = all_data[len(train_data) - 60:] # Using look_back=60 as in original code | |
| test_inputs = scaler.transform(test_inputs.reshape(-1, 1)) | |
| X_test = [] | |
| for i in range(60, len(test_inputs)): | |
| X_test.append(test_inputs[i-60: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 = load_arima_model() | |
| if arima_model: | |
| arima_forecast = arima_model.forecast(steps=days_to_predict) | |
| predictions['ARIMA'] = arima_forecast | |
| # Prophet | |
| prophet_model = load_prophet_model() | |
| 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 = load_lstm_model() | |
| if lstm_model and scaler: | |
| last_sequence = scaler.transform(full_data[-60:].reshape(-1, 1)) # Using look_back=60 | |
| lstm_predictions = [] | |
| for _ in range(days_to_predict): | |
| X_test = last_sequence.reshape((1, 60, 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=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 | |
| 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) | |
| plot = create_comparison_plot(results, train_data, test_data) | |
| metrics_table = format_metrics_table(results) | |
| 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: | |
| error_msg = f"### ❌ Error\n\n{str(e)}\n\nPlease make sure AAPL_stock_data.csv is uploaded." | |
| return None, error_msg | |
| # ============================================================================ | |
| # GRADIO INTERFACE | |
| # ============================================================================ | |
| 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(""" | |
| This application implements and compares **three time-series forecasting models** for Apple Inc. (AAPL) stock price prediction: | |
| - 🔴 **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.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] | |
| ) | |
| # 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] | |
| ) | |
| # TAB 3: Model Evaluation | |
| with gr.Tab("📊 Model Evaluation"): | |
| gr.Markdown(""" | |
| ### Rolling Window Evaluation | |
| 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(""" | |
| --- | |
| <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() |