Update app.py

app.py

@@ -1,136 +1,312 @@
+import json
+from pathlib import Path
+
 import gradio as gr
-import pandas as pd
+import matplotlib.pyplot as plt
 import numpy as np
+import pandas as pd
 from datasets import load_dataset
 from sklearn.ensemble import RandomForestRegressor
-from sklearn.metrics import r2_score
-import matplotlib.pyplot as plt
+from sklearn.metrics import mean_absolute_error, r2_score
+from sklearn.model_selection import train_test_split
+
+
+# =========================================================
+# CONFIG
+# =========================================================
+HF_DATASET_NAME = "QSBench/QSBench-Core-v1.0.0-demo"
+LOCAL_BENCHMARK_CSV = "noise_benchmark_results.csv"
+
+TARGET_COL = "ideal_expval_Z_global"
+
+EXCLUDE_COLS = {
+    "sample_id",
+    "sample_seed",
+    "ideal_expval_Z_global",
+    "ideal_expval_X_global",
+    "ideal_expval_Y_global",
+    "noisy_expval_Z_global",
+    "noisy_expval_X_global",
+    "noisy_expval_Y_global",
+    "error_Z_global",
+    "error_X_global",
+    "error_Y_global",
+    "sign_ideal_Z_global",
+    "sign_noisy_Z_global",
+    "sign_ideal_X_global",
+    "sign_noisy_X_global",
+    "sign_ideal_Y_global",
+    "sign_noisy_Y_global",
+}
+
+MODEL_PARAMS = dict(
+    n_estimators=80,
+    max_depth=10,
+    min_samples_leaf=2,
+    random_state=42,
+    n_jobs=-1,
+)
+
+
+# =========================================================
+# DATA LOADING
+# =========================================================
+def load_demo_dataset() -> pd.DataFrame:
+    ds_all = load_dataset(HF_DATASET_NAME)
+    df_all = pd.DataFrame(ds_all["train"])
+    return df_all
+
+
+def split_by_split_column(df: pd.DataFrame) -> dict:
+    if "split" not in df.columns:
+        return {"all": df.reset_index(drop=True)}
+
+    splits = {}
+    for split_name in df["split"].dropna().astype(str).unique():
+        splits[split_name] = df[df["split"].astype(str) == split_name].reset_index(drop=True)
+    return splits
+
 
-# Загружаем датасет и разделяем по колонке 'split'
-print("Loading dataset...")
-ds_all = load_dataset("QSBench/QSBench-Core-v1.0.0-demo")
-df_all = pd.DataFrame(ds_all['train'])
-
-splits = {}
-for split_name in df_all['split'].unique():
-    splits[split_name] = df_all[df_all['split'] == split_name].reset_index(drop=True)
-
-print("Available splits:", list(splits.keys()))
-
-# Список потенциальных признаков (числовые колонки, которые не являются целевыми или текстовыми)
-numeric_cols = df_all.select_dtypes(include=[np.number]).columns.tolist()
-# Исключаем явные целевые переменные и идентификаторы
-exclude = ['sample_id', 'sample_seed', 'ideal_expval_Z_global', 'ideal_expval_X_global', 'ideal_expval_Y_global',
-           'noisy_expval_Z_global', 'noisy_expval_X_global', 'noisy_expval_Y_global',
-           'error_Z_global', 'error_X_global', 'error_Y_global',
-           'sign_ideal_Z_global', 'sign_noisy_Z_global',
-           'ideal_expval_Z_q0', 'ideal_expval_Z_q1', 'ideal_expval_Z_q2', 'ideal_expval_Z_q3', 'ideal_expval_Z_q4', 'ideal_expval_Z_q5',
-           'noisy_expval_Z_q0', 'noisy_expval_Z_q1', 'noisy_expval_Z_q2', 'noisy_expval_Z_q3', 'noisy_expval_Z_q4', 'noisy_expval_Z_q5',
-           'ideal_expval_X_q0', 'ideal_expval_X_q1', 'ideal_expval_X_q2', 'ideal_expval_X_q3', 'ideal_expval_X_q4', 'ideal_expval_X_q5',
-           'noisy_expval_X_q0', 'noisy_expval_X_q1', 'noisy_expval_X_q2', 'noisy_expval_X_q3', 'noisy_expval_X_q4', 'noisy_expval_X_q5',
-           'ideal_expval_Y_q0', 'ideal_expval_Y_q1', 'ideal_expval_Y_q2', 'ideal_expval_Y_q3', 'ideal_expval_Y_q4', 'ideal_expval_Y_q5',
-           'noisy_expval_Y_q0', 'noisy_expval_Y_q1', 'noisy_expval_Y_q2', 'noisy_expval_Y_q3', 'noisy_expval_Y_q4', 'noisy_expval_Y_q5']
-feature_cols = [col for col in numeric_cols if col not in exclude and not col.startswith('error_')]
-
-# Целевая переменная
-target_col = "ideal_expval_Z_global"
-
-def show_data(split):
-    if split in splits:
-        return splits[split].head(10)
-    else:
-        return f"Split '{split}' not found"
-
-def train_model():
-    if 'train' not in splits or 'test' not in splits:
-        return None, "Error: train or test split not found in dataset"
-
-    # Проверяем наличие признаков
-    available_features = [col for col in feature_cols if col in splits['train'].columns]
-    if not available_features:
-        return None, f"Error: no numeric feature columns found (tried: {feature_cols})"
-
-    X_train = splits['train'][available_features]
-    y_train = splits['train'][target_col]
-    X_test = splits['test'][available_features]
-    y_test = splits['test'][target_col]
-
-    model = RandomForestRegressor(n_estimators=100, random_state=42)
+def get_numeric_feature_cols(df: pd.DataFrame) -> list[str]:
+    numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+    feature_cols = [c for c in numeric_cols if c not in EXCLUDE_COLS and not c.startswith("error_")]
+    return feature_cols
+
+
+def load_benchmark_results() -> pd.DataFrame:
+    path = Path(LOCAL_BENCHMARK_CSV)
+    if not path.exists():
+        return pd.DataFrame(
+            [
+                {
+                    "dataset": "noise_benchmark_results.csv not found",
+                    "split_used": "",
+                    "n_samples": 0,
+                    "r2": np.nan,
+                    "mae": np.nan,
+                    "avg_noise_prob": np.nan,
+                    "status": "missing_file",
+                }
+            ]
+        )
+
+    df = pd.read_csv(path)
+    return df
+
+
+# =========================================================
+# DATA EXPLORER TAB
+# =========================================================
+def show_data(split_name, splits_cache):
+    if not splits_cache:
+        return pd.DataFrame([{"message": "Dataset not loaded"}])
+
+    if split_name in splits_cache:
+        return splits_cache[split_name].head(10)
+
+    first_key = next(iter(splits_cache.keys()))
+    return splits_cache[first_key].head(10)
+
+
+# =========================================================
+# MODEL DEMO TAB
+# =========================================================
+def train_model_demo(df: pd.DataFrame):
+    if TARGET_COL not in df.columns:
+        return None, "Target column not found."
+
+    feature_cols = get_numeric_feature_cols(df)
+    if not feature_cols:
+        return None, "No numeric feature columns found."
+
+    work_df = df.dropna(subset=feature_cols + [TARGET_COL]).reset_index(drop=True)
+
+    X = work_df[feature_cols]
+    y = work_df[TARGET_COL]
+
+    if len(work_df) < 20:
+        return None, "Not enough rows for a stable demo."
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42
+    )
+
+    model = RandomForestRegressor(**MODEL_PARAMS)
     model.fit(X_train, y_train)
-    y_pred = model.predict(X_test)
-    r2 = r2_score(y_test, y_pred)
+    preds = model.predict(X_test)
+
+    r2 = r2_score(y_test, preds)
+    mae = mean_absolute_error(y_test, preds)
 
-    # График предсказаний
-    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
-    ax1.scatter(y_test, y_pred, alpha=0.5)
-    ax1.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--')
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(13, 5))
+
+    ax1.scatter(y_test, preds, alpha=0.6)
+    min_v = min(float(y_test.min()), float(np.min(preds)))
+    max_v = max(float(y_test.max()), float(np.max(preds)))
+    ax1.plot([min_v, max_v], [min_v, max_v], linestyle="--")
     ax1.set_xlabel("True value")
-    ax1.set_ylabel("Predicted")
-    ax1.set_title(f"Predictions vs. Truth\nR² = {r2:.4f}")
+    ax1.set_ylabel("Predicted value")
+    ax1.set_title(f"Predictions vs Truth\nR² = {r2:.4f}, MAE = {mae:.4f}")
 
-    # Важность признаков
     importances = model.feature_importances_
-    indices = np.argsort(importances)[-10:]  # топ-10 признаков
-    ax2.barh(range(len(indices)), importances[indices])
-    ax2.set_yticks(range(len(indices)))
-    ax2.set_yticklabels([available_features[i] for i in indices])
+    top_idx = np.argsort(importances)[-10:]
+    ax2.barh(range(len(top_idx)), importances[top_idx])
+    ax2.set_yticks(range(len(top_idx)))
+    ax2.set_yticklabels([feature_cols[i] for i in top_idx])
     ax2.set_xlabel("Feature importance")
-    ax2.set_title("Top 10 most important features")
+    ax2.set_title("Top 10 features")
 
     plt.tight_layout()
-    explanation = f"""
-    **R² score:** {r2:.4f}
 
-    **What does it mean?**  
-    R² measures how well the model explains the variance in the target.  
-    - 1.0 = perfect prediction  
-    - 0.0 = model predicts the mean (no better than guessing)  
-    - Negative values = model performs worse than guessing the mean.
+    explanation = f"""
+**R² score:** {r2:.4f}  
+**MAE:** {mae:.4f}
 
-    The current score is negative, which indicates that the chosen features (`total_gates`, `gate_entropy`, `meyer_wallach`, and others) are not strongly predictive of the ideal Z expectation value on this small dataset.  
-    This is expected: quantum expectation values depend on many subtle circuit details. Larger datasets with richer features would allow better models.
+This is a lightweight baseline on the demo dataset. The point is not to get a perfect score, but to show that the dataset contains real structure and can support quantum ML experiments.
+"""
 
-    👉 **Our full datasets** contain up to 200,000 circuits, additional noise models, and more features – perfect for serious Quantum Machine Learning research.
-    """
     return fig, explanation
 
-# Интерфейс
-with gr.Blocks(title="QSBench Demo Explorer") as demo:
-    gr.Markdown("""
-    # QSBench Core Demo Explorer
-    Interactive demo of the **QSBench Core Demo** dataset – 200 synthetic quantum circuits (6 qubits, depth 4).  
-    This space shows how to load the data, inspect it, and train a simple model on the ideal expectation values.
-
-    👉 **Full datasets (up to 200k samples, noisy versions, 10‑qubit transpilation packs) are available for purchase.**  
-    [Visit the QSBench website](https://qsbench.github.io/)
-    """)
-
-    with gr.Tabs():
-        with gr.TabItem("Data Explorer"):
-            split_selector = gr.Dropdown(
-                choices=list(splits.keys()),
-                label="Choose a split",
-                value=list(splits.keys())[0] if splits else None
-            )
-            data_table = gr.Dataframe(label="First 10 rows", interactive=False)
-            split_selector.change(fn=show_data, inputs=split_selector, outputs=data_table)
-            demo.load(fn=lambda: show_data(list(splits.keys())[0]), outputs=data_table)
-
-        with gr.TabItem("Model Demo"):
-            train_button = gr.Button("Train Random Forest")
-            plot_output = gr.Plot()
-            text_output = gr.Markdown()
-            train_button.click(fn=train_model, outputs=[plot_output, text_output])
-
-    gr.Markdown("---")
-    gr.Markdown("""
-    ### Get the full datasets
-    - **QSBench Core** – 75k clean circuits (8 qubits)  
-    - **Depolarizing Noise Pack** – 150k circuits with depolarizing noise  
-    - **Amplitude Damping Pack** – 150k circuits with T1‑like relaxation  
-    - **Transpilation Hardware Pack** – 200k circuits (10 qubits) with hardware‑aware transpilation  
-
-    🔗 [Browse all datasets and purchase licenses](https://qsbench.github.io/)
-    """)
-
-demo.launch()
+
+# =========================================================
+# BENCHMARK TAB
+# =========================================================
+def make_bar_plot(df: pd.DataFrame, value_col: str, title: str, ylabel: str):
+    fig, ax = plt.subplots(figsize=(9, 4.8))
+    if df.empty or value_col not in df.columns or "dataset" not in df.columns:
+        ax.text(0.5, 0.5, "No benchmark data available", ha="center", va="center")
+        ax.axis("off")
+        return fig
+
+    plot_df = df.copy()
+    plot_df = plot_df.dropna(subset=[value_col])
+
+    ax.bar(plot_df["dataset"].astype(str), plot_df[value_col].astype(float))
+    ax.set_title(title)
+    ax.set_xlabel("Dataset")
+    ax.set_ylabel(ylabel)
+    ax.tick_params(axis="x", rotation=20)
+    ax.axhline(0, linewidth=1)
+    plt.tight_layout()
+    return fig
+
+
+def build_benchmark_dashboard():
+    df = load_benchmark_results()
+
+    explanation = """
+### Noise robustness benchmark
+
+This dashboard shows how a model trained on clean circuits behaves on:
+- **core_clean**
+- **depolarizing**
+- **amplitude_damping**
+- **transpilation**
+
+A sharp drop in R² indicates strong distribution shift. That is exactly the value of the larger QSBench packs.
+"""
+
+    r2_fig = make_bar_plot(df, "r2", "Noise Robustness Benchmark — R²", "R²")
+    mae_fig = make_bar_plot(df, "mae", "Noise Robustness Benchmark — MAE", "MAE")
+
+    return df, r2_fig, mae_fig, explanation
+
+
+# =========================================================
+# APP
+# =========================================================
+def main():
+    print("Loading demo dataset...")
+    df_all = load_demo_dataset()
+    splits_cache = split_by_split_column(df_all)
+    split_choices = list(splits_cache.keys())
+
+    default_split = split_choices[0] if split_choices else None
+
+    with gr.Blocks(title="QSBench Demo Explorer") as demo:
+        gr.Markdown(
+            """
+# QSBench Demo Explorer
+
+Interactive demo for the QSBench Core demo dataset and precomputed noise robustness benchmark.
+"""
+        )
+
+        with gr.Tabs():
+            with gr.TabItem("Data Explorer"):
+                gr.Markdown("Inspect the demo dataset split by split.")
+                split_selector = gr.Dropdown(
+                    choices=split_choices,
+                    value=default_split,
+                    label="Choose a split",
+                )
+                data_table = gr.Dataframe(label="First 10 rows", interactive=False)
+
+                split_selector.change(
+                    fn=lambda s: show_data(s, splits_cache),
+                    inputs=split_selector,
+                    outputs=data_table,
+                )
+
+                demo.load(
+                    fn=lambda: show_data(default_split, splits_cache),
+                    inputs=[],
+                    outputs=data_table,
+                )
+
+            with gr.TabItem("Model Demo"):
+                gr.Markdown(
+                    """
+Train a lightweight Random Forest baseline on the demo data and inspect predictions.
+"""
+                )
+                train_button = gr.Button("Train model")
+                plot_output = gr.Plot()
+                text_output = gr.Markdown()
+
+                train_button.click(
+                    fn=lambda: train_model_demo(df_all),
+                    inputs=[],
+                    outputs=[plot_output, text_output],
+                )
+
+            with gr.TabItem("Noise Robustness Benchmark"):
+                gr.Markdown(
+                    """
+This tab loads the precomputed local benchmark results from `noise_benchmark_results.csv`.
+"""
+                )
+                refresh_button = gr.Button("Load benchmark results")
+                benchmark_table = gr.Dataframe(label="Benchmark results", interactive=False)
+                r2_plot = gr.Plot(label="R² plot")
+                mae_plot = gr.Plot(label="MAE plot")
+                benchmark_text = gr.Markdown()
+
+                refresh_button.click(
+                    fn=build_benchmark_dashboard,
+                    inputs=[],
+                    outputs=[benchmark_table, r2_plot, mae_plot, benchmark_text],
+                )
+
+                demo.load(
+                    fn=build_benchmark_dashboard,
+                    inputs=[],
+                    outputs=[benchmark_table, r2_plot, mae_plot, benchmark_text],
+                )
+
+        gr.Markdown("---")
+        gr.Markdown(
+            """
+### What this demo shows
+
+- Data Explorer: inspect the dataset splits
+- Model Demo: quick baseline on the demo data
+- Noise Robustness Benchmark: precomputed results that show how performance changes across clean, noisy, and transpiled datasets
+"""
+        )
+
+    demo.launch()
+
+
+if __name__ == "__main__":
+    main()