update app.py

app.py

@@ -11,39 +11,40 @@ from huggingface_hub import snapshot_download
 from visionts import VisionTSpp, freq_to_seasonality_list
 
 # ========================
-# 配置
+# 1. Configuration
 # ========================
 DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
 REPO_ID = "Lefei/VisionTSpp"
 LOCAL_DIR = "./hf_models/VisionTSpp"
 CKPT_PATH = os.path.join(LOCAL_DIR, "visiontspp_model.ckpt")
-
 ARCH = 'mae_base'
 
-# 下载模型
+# Download the model from Hugging Face Hub
 if not os.path.exists(CKPT_PATH):
     os.makedirs(LOCAL_DIR, exist_ok=True)
     print("Downloading model from Hugging Face Hub...")
     snapshot_download(repo_id=REPO_ID, local_dir=LOCAL_DIR, local_dir_use_symlinks=False)
 
-# 加载模型
+# Load the model
+# NOTE: We assume the model was trained to predict these specific quantiles
+QUANTILES = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
 model = VisionTSpp(
     ARCH,
     ckpt_path=CKPT_PATH,
-    quantile=True,
+    quantiles=QUANTILES,  # Set the quantiles the model should predict
     clip_input=True,
     complete_no_clip=False,
     color=True
 ).to(DEVICE)
 print(f"Model loaded on {DEVICE}")
 
-# Image normalization
+# Image normalization constants
 imagenet_mean = np.array([0.485, 0.456, 0.406])
 imagenet_std = np.array([0.229, 0.224, 0.225])
 
 
 # ========================
-# 预设数据集
+# 2. Preset Datasets
 # ========================
 PRESET_DATASETS = {
     "ETTm1 (15-min)": "https://raw.githubusercontent.com/zhouhaoyi/ETDataset/main/ETT-small/ETTm1.csv",
@@ -52,15 +53,19 @@ PRESET_DATASETS = {
     "Weather": "https://raw.githubusercontent.com/zhouhaoyi/ETDataset/main/weather.csv"
 }
 
-# 本地缓存路径
+# Local cache path for presets
 PRESET_DIR = "./preset_data"
 os.makedirs(PRESET_DIR, exist_ok=True)
 
 
 def load_preset_data(name):
+    """Loads a preset dataset, caching it locally."""
     url = PRESET_DATASETS[name]
-    path = os.path.join(PRESET_DIR, f"{name.split(' ')[0]}.csv")
+    # Sanitize name for file path
+    sanitized_name = name.split(' ')[0]
+    path = os.path.join(PRESET_DIR, f"{sanitized_name}.csv")
     if not os.path.exists(path):
+        print(f"Downloading preset dataset: {name}...")
         df = pd.read_csv(url)
         df.to_csv(path, index=False)
     else:
@@ -69,91 +74,110 @@ def load_preset_data(name):
 
 
 # ========================
-# 可视化函数
+# 3. Visualization Functions
 # ========================
 
-def show_image_tensor(image, title='', cur_nvars=1, cur_color_list=None):
+def show_image_tensor(image_tensor, title='', cur_nvars=1, cur_color_list=None):
+    """
+    Visualizes a tensor as an image, handling un-normalization.
+    Returns a matplotlib Figure object for Gradio.
+    """
+    if image_tensor is None: return None
+    # image_tensor is [C, H, W] but we expect [H, W, C] for imshow
+    # The model outputs [1, 1, C, H, W], after indexing it's [C, H, W]
+    image = image_tensor.permute(1, 2, 0).cpu() # H, W, C
+
     cur_image = torch.zeros_like(image)
     height_per_var = image.shape[0] // cur_nvars
+    
+    # Assign colors to variables for visualization
     for i in range(cur_nvars):
-        cur_color = cur_color_list[i]
-        cur_image[i*height_per_var:(i+1)*height_per_var, :, cur_color] = \
-            (image[i*height_per_var:(i+1)*height_per_var, :, cur_color] * imagenet_std[cur_color] + imagenet_mean[cur_color]) * 255
-    cur_image = torch.clamp(cur_image, 0, 255).cpu().int()
+        cur_color_idx = cur_color_list[i]
+        var_slice = image[i*height_per_var:(i+1)*height_per_var, :, :]
+        # Un-normalize only the used color channel
+        unnormalized_channel = var_slice[:, :, cur_color_idx] * imagenet_std[cur_color_idx] + imagenet_mean[cur_color_idx]
+        cur_image[i*height_per_var:(i+1)*height_per_var, :, cur_color_idx] = unnormalized_channel * 255
+        
+    cur_image = torch.clamp(cur_image, 0, 255).int().numpy()
 
     fig, ax = plt.subplots(figsize=(6, 6))
-    ax.imshow(cur_image.numpy())
+    ax.imshow(cur_image)
     ax.set_title(title, fontsize=14)
     ax.axis('off')
-    plt.close(fig)
+    plt.tight_layout()
+    plt.close(fig) # Close to prevent double display
     return fig
 
 
-def visual_ts_with_quantiles(true, pred_median, pred_quantiles, lookback_len_visual=300, pred_len=96, quantile_colors=None):
+def visual_ts_with_quantiles(true_data, pred_median, pred_quantiles_list, model_quantiles, context_len, pred_len):
     """
-    可视化中叠加多个 quantile 区间
-    pred_quantiles: list of [pred_len, nvars] tensors
+    Visualizes time series with multiple quantile bands.
+    pred_quantiles_list: list of tensors, one for each quantile.
+    model_quantiles: The list of quantiles values, e.g., [0.1, 0.2, ..., 0.9].
     """
-    if isinstance(true, torch.Tensor):
-        true = true.cpu().numpy()
-    if isinstance(pred_median, torch.Tensor):
-        pred_median = pred_median.cpu().numpy()
-    for i, q in enumerate(pred_quantiles):
+    if isinstance(true_data, torch.Tensor): true_data = true_data.cpu().numpy()
+    if isinstance(pred_median, torch.Tensor): pred_median = pred_median.cpu().numpy()
+    for i, q in enumerate(pred_quantiles_list):
         if isinstance(q, torch.Tensor):
-            pred_quantiles[i] = q.cpu().numpy()
-
-    nvars = true.shape[1]
-    FIG_WIDTH = 12
-    FIG_HEIGHT_PER_VAR = 1.8
-    FONT_S = 10
-
-    fig, axes = plt.subplots(
-        nrows=nvars, ncols=1, figsize=(FIG_WIDTH, nvars * FIG_HEIGHT_PER_VAR), sharex=True,
-        gridspec_kw={'height_ratios': [1] * nvars}
-    )
-    if nvars == 1:
-        axes = [axes]
-
-    lookback_len = true.shape[0] - pred_len
-
-    # Quantile 颜色（从外到内）
-    if quantile_colors is None:
-        quantile_colors = ['lightblue', 'skyblue', 'deepskyblue']
+            pred_quantiles_list[i] = q.cpu().numpy()
+
+    nvars = true_data.shape[1]
+    FIG_WIDTH = 15
+    FIG_HEIGHT_PER_VAR = 2.0
+    
+    fig, axes = plt.subplots(nvars, 1, figsize=(FIG_WIDTH, nvars * FIG_HEIGHT_PER_VAR), sharex=True)
+    if nvars == 1: axes = [axes]
+
+    # Combine quantiles and predictions
+    sorted_quantiles = sorted(zip(model_quantiles, pred_quantiles_list + [pred_median]), key=lambda x: x[0])
+    
+    # Filter out the median to get pairs for bands
+    quantile_preds = [item[1] for item in sorted_quantiles if item[0] != 0.5]
+    quantile_vals = [item[0] for item in sorted_quantiles if item[0] != 0.5]
+    
+    num_bands = len(quantile_preds) // 2
+    # Colors from light to dark for bands from widest to narrowest
+    quantile_colors = plt.cm.Blues(np.linspace(0.3, 0.8, num_bands))[::-1]
 
     for i, ax in enumerate(axes):
-        ax.plot(true[:, i], label='Ground Truth', color='gray', linewidth=2)
-        ax.plot(np.arange(lookback_len, len(true)), pred_median[lookback_len:, i],
-                label='Prediction (Median)', color='blue', linewidth=2)
-
-        # 绘制 quantile 区间（从外到内）
-        base = pred_median[lookback_len:]
-        quantiles_sorted = sorted(zip(PREDS.quantiles, pred_quantiles), key=lambda x: x[0])
-        for (q, pred_q), color in zip(quantiles_sorted, quantile_colors):
-            upper = pred_q[lookback_len:]
-            lower = 2 * base - upper  # 对称假设
+        # Plot ground truth and median prediction
+        ax.plot(true_data[:, i], label='Ground Truth', color='black', linewidth=1.5)
+        pred_range = np.arange(context_len, context_len + pred_len)
+        ax.plot(pred_range, pred_median[:, i], label='Prediction (Median)', color='red', linewidth=1.5)
+
+        # Plot quantile bands
+        for j in range(num_bands):
+            lower_quantile_pred = quantile_preds[j][:, i]
+            upper_quantile_pred = quantile_preds[-(j+1)][:, i]
+            q_low = quantile_vals[j]
+            q_high = quantile_vals[-(j+1)]
+            
             ax.fill_between(
-                np.arange(lookback_len, len(true)),
-                lower[:, i], upper[:, i],
-                color=color, alpha=0.5, label=f'Quantile {q:.1f}'
+                pred_range, lower_quantile_pred, upper_quantile_pred,
+                color=quantile_colors[j], alpha=0.7,
+                label=f'{int(q_low*100)}-{int(q_high*100)}% Quantile'
             )
 
         y_min, y_max = ax.get_ylim()
-        ax.vlines(x=lookback_len, ymin=y_min, ymax=y_max, colors='gray', linestyles='--', alpha=0.7)
-        ax.set_yticks([])
-        ax.set_xticks([])
-        ax.text(0.005, 0.8, f'Var {i+1}', transform=ax.transAxes, fontsize=FONT_S, weight='bold')
+        ax.vlines(x=context_len, ymin=y_min, ymax=y_max, colors='gray', linestyles='--', alpha=0.7)
+        ax.set_ylabel(f'Var {i+1}', rotation=0, labelpad=30, ha='right', va='center')
+        ax.grid(True, which='both', linestyle='--', linewidth=0.5)
+        ax.margins(x=0)
 
     handles, labels = axes[0].get_legend_handles_labels()
-    fig.legend(handles, labels, loc='upper right', bbox_to_anchor=(0.9, 0.9), prop={'size': FONT_S})
-    plt.subplots_adjust(hspace=0)
+    # Create a unique legend
+    unique_labels = dict(zip(labels, handles))
+    fig.legend(unique_labels.values(), unique_labels.keys(), loc='upper center', bbox_to_anchor=(0.5, 1.05), ncol=num_bands + 2)
+    plt.tight_layout(rect=[0, 0, 1, 0.95])
     plt.close(fig)
     return fig
 
 
 # ========================
-# 预测类封装（便于复用）
+# 4. Prediction Logic
 # ========================
 class PredictionResult:
+    """A data class to hold prediction results for easier handling."""
     def __init__(self, ts_fig, input_img_fig, recon_img_fig, csv_path, total_samples):
         self.ts_fig = ts_fig
         self.input_img_fig = input_img_fig
@@ -162,175 +186,213 @@ class PredictionResult:
         self.total_samples = total_samples
 
 
-def predict_at_index(df, index, context_len=960, pred_len=394, freq="15Min"):
-    # === 数据校验 ===
+def predict_at_index(df, index, context_len, pred_len, freq):
+    """Performs a full prediction cycle for a given sample index."""
+    # === Data Validation ===
     if 'date' not in df.columns:
-        raise ValueError("❌ 数据集必须包含名为 'date' 的时间列。")
+        raise gr.Error("❌ Input CSV must contain a 'date' column.")
 
     try:
         df['date'] = pd.to_datetime(df['date'])
     except Exception:
-        raise ValueError("❌ 'date' 列格式无法解析为时间，请检查日期格式。")
+        raise gr.Error("❌ The 'date' column could not be parsed. Please check the date format (e.g., YYYY-MM-DD HH:MM:SS).")
 
     df = df.sort_values('date').set_index('date')
-    data = df.values
+    data = df.select_dtypes(include=np.number).values
     nvars = data.shape[1]
 
     total_samples = len(data) - context_len - pred_len + 1
     if total_samples <= 0:
-        raise ValueError(f"数据太短，至少需要 {context_len + pred_len} 行，当前只有 {len(data)} 行。")
-    if index >= total_samples:
-        raise ValueError(f"索引越界，最大允许索引为 {total_samples - 1}")
+        raise gr.Error(f"Data is too short. It needs at least {context_len + pred_len} rows, but has {len(data)}.")
+    
+    # Clamp index to valid range, defaulting to the last sample
+    index = max(0, min(index, total_samples - 1))
 
-    # 归一化
+    # Normalize data (simple train/test split for mean/std)
     train_len = int(len(data) * 0.7)
     x_mean = data[:train_len].mean(axis=0, keepdims=True)
     x_std = data[:train_len].std(axis=0, keepdims=True) + 1e-8
     data_norm = (data - x_mean) / x_std
 
+    # Get data for the selected sample
     start_idx = index
-    x = data_norm[start_idx:start_idx + context_len]
-    y_true = data_norm[start_idx + context_len:start_idx + context_len + pred_len]
+    x_norm = data_norm[start_idx : start_idx + context_len]
+    y_true_norm = data_norm[start_idx + context_len : start_idx + context_len + pred_len]
+    x_tensor = torch.FloatTensor(x_norm).unsqueeze(0).to(DEVICE)
 
+    # Configure model and run prediction
     periodicity_list = freq_to_seasonality_list(freq)
     periodicity = periodicity_list[0] if periodicity_list else 1
     color_list = [i % 3 for i in range(nvars)]
-
     model.update_config(context_len=context_len, pred_len=pred_len, periodicity=periodicity)
 
-    x_tensor = torch.FloatTensor(x).unsqueeze(0).to(DEVICE)
-
     with torch.no_grad():
-        y_pred, input_image, reconstructed_image, nvars_out, color_list_out = model.forward(
+        y_pred, input_image, reconstructed_image, _, _ = model.forward(
             x_tensor, export_image=True, color_list=color_list
         )
-        pred_median, pred_quantiles = y_pred  # list of quantiles
-
-    # 反归一化
-    y_true_orig = y_true * x_std + x_mean
-    pred_med_orig = pred_median[0].cpu().numpy() * x_std + x_mean
-    pred_quants_orig = [q[0].cpu().numpy() * x_std + x_mean for q in pred_quantiles]
-
-    # 完整序列
-    full_true = np.concatenate([x * x_std + x_mean, y_true_orig], axis=0)
-    full_pred_med = np.concatenate([x * x_std + x_mean, pred_med_orig], axis=0)
-
-    # === 可视化 ===
+        # The model returns a list of all quantile predictions including the median
+        # The order depends on the model's internal quantile list
+        # Let's separate median (0.5) from other quantiles
+        all_preds = dict(zip(model.quantiles, y_pred))
+        pred_median_norm = all_preds.pop(0.5)[0] # Shape [pred_len, nvars]
+        pred_quantiles_norm = list(all_preds.values())
+        pred_quantiles_norm = [q[0] for q in pred_quantiles_norm] # List of [pred_len, nvars]
+
+    # Un-normalize results
+    y_true = y_true_norm * x_std + x_mean
+    pred_median = pred_median_norm.cpu().numpy() * x_std + x_mean
+    pred_quantiles = [q.cpu().numpy() * x_std + x_mean for q in pred_quantiles_norm]
+
+    # Create full series for plotting
+    full_true_context = data[start_idx : start_idx + context_len]
+    full_true_series = np.concatenate([full_true_context, y_true], axis=0)
+    
+    # === Visualization ===
     ts_fig = visual_ts_with_quantiles(
-        true=full_true,
-        pred_median=full_pred_med,
-        pred_quantiles=pred_quants_orig,
-        lookback_len_visual=context_len,
+        true_data=full_true_series,
+        pred_median=pred_median,
+        pred_quantiles_list=pred_quantiles,
+        model_quantiles=list(all_preds.keys()), # Quantiles without median
+        context_len=context_len,
         pred_len=pred_len
     )
-
     input_img_fig = show_image_tensor(input_image[0, 0], f'Input Image (Sample {index})', nvars, color_list)
     recon_img_fig = show_image_tensor(reconstructed_image[0, 0], 'Reconstructed Image', nvars, color_list)
 
-    # === 保存 CSV ===
+    # === Save CSV ===
     os.makedirs("outputs", exist_ok=True)
     csv_path = "outputs/prediction_result.csv"
-    time_index = df.index[start_idx:start_idx + context_len + pred_len]
-    combined = np.concatenate([full_true, full_pred_med], axis=1)  # [T, 2*nvars]
-    col_names = [f"True_Var{i+1}" for i in range(nvars)] + [f"Pred_Var{i+1}" for i in range(nvars)]
-    result_df = pd.DataFrame(combined, index=time_index, columns=col_names)
-    result_df.to_csv(csv_path)
+    time_index = df.index[start_idx + context_len : start_idx + context_len + pred_len]
+    
+    result_data = {'date': time_index}
+    for i in range(nvars):
+        result_data[f'True_Var{i+1}'] = y_true[:, i]
+        result_data[f'Pred_Median_Var{i+1}'] = pred_median[:, i]
+    result_df = pd.DataFrame(result_data)
+    result_df.to_csv(csv_path, index=False)
 
     return PredictionResult(ts_fig, input_img_fig, recon_img_fig, csv_path, total_samples)
 
 
 # ========================
-# Gradio 接口函数
+# 5. Gradio Interface
 # ========================
 def run_forecast(data_source, upload_file, index, context_len, pred_len, freq):
+    """Wrapper function for the Gradio interface."""
     if data_source == "Upload CSV":
         if upload_file is None:
-            raise ValueError("请上传一个 CSV 文件")
+            raise gr.Error("Please upload a CSV file when 'Upload CSV' is selected.")
         df = pd.read_csv(upload_file.name)
     else:
         df = load_preset_data(data_source)
 
     try:
-        result = predict_at_index(df, int(index), context_len=int(context_len), pred_len=int(pred_len), freq=freq)
+        # Cast inputs to correct types
+        index, context_len, pred_len = int(index), int(context_len), int(pred_len)
+
+        result = predict_at_index(df, index, context_len, pred_len, freq)
+        
+        # On the first run, set the slider to the last sample
+        if index >= result.total_samples:
+            final_index = result.total_samples - 1
+        else:
+            final_index = index
+            
         return (
             result.ts_fig,
             result.input_img_fig,
             result.recon_img_fig,
             result.csv_path,
-            gr.update(maximum=result.total_samples - 1, value=min(index, result.total_samples - 1))
+            gr.update(maximum=result.total_samples - 1, value=final_index) # Update slider
         )
     except Exception as e:
-        fig_err = plt.figure(figsize=(6, 4))
-        plt.text(0.5, 0.5, f"Error: {str(e)}", ha='center', va='center', wrap=True)
+        # Handle errors gracefully by displaying them
+        error_fig = plt.figure(figsize=(10, 5))
+        plt.text(0.5, 0.5, f"An error occurred:\n{str(e)}", ha='center', va='center', wrap=True, color='red', fontsize=12)
         plt.axis('off')
-        plt.close(fig_err)
-        return fig_err, fig_err, fig_err, None, gr.update()
-
-
-# ========================
-# Gradio UI
-# ========================
-with gr.Blocks(title="VisionTS++ 高级预测平台") as demo:
-    gr.Markdown("# 🕰️ VisionTS++ 多变量时间序列预测平台")
-    gr.Markdown("""
-    - ✅ 支持预设数据集或本地上传
-    - ✅ 上传规则：必须是 `.csv`，且包含 `date` 列
-    - ✅ 显示多分位数预测区间
-    - ✅ 支持下载预测结果
-    - ✅ 滑动样本实时预测
-    """)
-
+        plt.close(error_fig)
+        # Return empty plots and no file
+        return error_fig, None, None, None, gr.update()
+
+
+# UI Layout
+with gr.Blocks(title="VisionTS++ Advanced Forecasting Platform", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🕰️ VisionTS++: Multivariate Time Series Forecasting")
+    gr.Markdown(
+        """
+        An interactive platform to explore time series forecasting using the VisionTS++ model.
+        - ✅ **Select** from preset datasets or **upload** your own.
+        - ✅ **Visualize** predictions with multiple **quantile uncertainty bands**.
+        - ✅ **Inspect** the model's internal "image" representation of the time series.
+        - ✅ **Slide** through different samples of the dataset for real-time forecasting.
+        - ✅ **Download** the prediction results as a CSV file.
+        """
+    )
+    
     with gr.Row():
-        with gr.Column(scale=2):
+        with gr.Column(scale=1, min_width=300):
+            gr.Markdown("### 1. Data & Model Configuration")
             data_source = gr.Dropdown(
-                label="选择数据源",
+                label="Select Data Source",
                 choices=["ETTm1 (15-min)", "ETTh1 (1-hour)", "Illness", "Weather", "Upload CSV"],
                 value="ETTm1 (15-min)"
             )
-            upload_file = gr.File(label="上传 CSV 文件", file_types=['.csv'], visible=False)
-            context_len = gr.Number(label="历史长度", value=960)
-            pred_len = gr.Number(label="预测长度", value=394)
-            freq = gr.Textbox(label="频率 (如 15Min, H)", value="15Min")
-            sample_index = gr.Slider(label="样本索引", minimum=0, maximum=100, step=1, value=0)
+            upload_file = gr.File(label="Upload CSV File", file_types=['.csv'], visible=False)
+            gr.Markdown(
+                """
+                **Upload Rules:**
+                1. Must be a `.csv` file.
+                2. Must contain a time column named `date`.
+                """
+            )
+            
+            context_len = gr.Number(label="Context Length (History)", value=336)
+            pred_len = gr.Number(label="Prediction Length (Future)", value=96)
+            freq = gr.Textbox(label="Frequency (e.g., 15Min, H, D)", value="15Min")
+
+            run_btn = gr.Button("🚀 Run Forecast", variant="primary")
+            
+            gr.Markdown("### 2. Sample Selection")
+            # Set a high initial value to default to the last sample on first run.
+            sample_index = gr.Slider(label="Sample Index", minimum=0, maximum=1000, step=1, value=10000)
 
         with gr.Column(scale=3):
-            ts_plot = gr.Plot(label="时间序列预测（含分位数区间）")
+            gr.Markdown("### 3. Prediction Results")
+            ts_plot = gr.Plot(label="Time Series Forecast with Quantile Bands")
             with gr.Row():
-                input_img_plot = gr.Plot(label="Input Image")
+                input_img_plot = gr.Plot(label="Input as Image")
                 recon_img_plot = gr.Plot(label="Reconstructed Image")
-            download_csv = gr.File(label="下载预测结果")
+            download_csv = gr.File(label="Download Prediction CSV")
 
-    btn = gr.Button("🚀 初始运行")
+    # --- Event Handlers ---
+    
+    # Show/hide upload button based on data source
+    def toggle_upload_visibility(choice):
+        return gr.update(visible=(choice == "Upload CSV"))
 
-    # 上传切换
-    def toggle_upload(choice):
-        return gr.update(visible=choice == "Upload CSV")
+    data_source.change(fn=toggle_upload_visibility, inputs=data_source, outputs=upload_file)
 
-    data_source.change(fn=toggle_upload, inputs=data_source, outputs=upload_file)
+    # Define the inputs and outputs for the forecast function
+    inputs = [data_source, upload_file, sample_index, context_len, pred_len, freq]
+    outputs = [ts_plot, input_img_plot, recon_img_plot, download_csv, sample_index]
 
-    # 初始运行 + 滑动条变化都触发
-    btn.click(
-        fn=run_forecast,
-        inputs=[data_source, upload_file, sample_index, context_len, pred_len, freq],
-        outputs=[ts_plot, input_img_plot, recon_img_plot, download_csv, sample_index]
-    )
+    # Trigger forecast on button click
+    run_btn.click(fn=run_forecast, inputs=inputs, outputs=outputs, api_name="run_forecast")
 
-    # 【关键】滑动条变化时重新预测
-    sample_index.change(
-        fn=run_forecast,
-        inputs=[data_source, upload_file, sample_index, context_len, pred_len, freq],
-        outputs=[ts_plot, input_img_plot, recon_img_plot, download_csv, sample_index]
-    )
-
-    # 示例
+    # Trigger forecast when the slider value changes
+    sample_index.release(fn=run_forecast, inputs=inputs, outputs=outputs, api_name="run_forecast_on_slide")
+    
+    # Examples
     gr.Examples(
         examples=[
-            ["ETTm1 (15-min)", None, 960, 394, "15Min"],
-            ["Illness", None, 36, 24, "D"]
+            ["ETTm1 (15-min)", None, 0, 336, 96, "15Min"],
+            ["Illness", None, 0, 36, 24, "D"],
+            ["Weather", None, 0, 96, 192, "H"]
         ],
-        inputs=[data_source, upload_file, context_len, pred_len, freq],
-        fn=lambda a,b,c,d,e: run_forecast(a,b,0,c,d,e),
-        label="点击运行示例"
+        inputs=[data_source, upload_file, sample_index, context_len, pred_len, freq],
+        fn=run_forecast, # The button click will trigger the run
+        outputs=outputs,
+        label="Click an example to load configuration, then click 'Run Forecast'"
     )
 
-demo.launch()
+demo.launch(debug=True)