Update app.py

app.py

@@ -11,11 +11,10 @@ from sklearn.ensemble import RandomForestRegressor
 from sklearn.metrics import mean_absolute_error, r2_score
 from sklearn.model_selection import train_test_split
 
-# Setup production-style logging
+# Setup logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Configuration for datasets and their specific metadata branches
 REPO_CONFIG = {
     "Core (Clean)": {
         "repo": "QSBench/QSBench-Core-v1.0.0-demo",
@@ -39,7 +38,6 @@ REPO_CONFIG = {
     }
 }
 
-# Features that should never be used as training inputs
 NON_FEATURE_COLS = {
     "sample_id", "sample_seed", "circuit_hash", "split", "circuit_qasm", 
     "qasm_raw", "qasm_transpiled", "circuit_type_resolved", "circuit_type_requested",
@@ -50,175 +48,132 @@ NON_FEATURE_COLS = {
 _ASSET_CACHE = {}
 
 def fetch_remote_json(url: str) -> Optional[dict]:
-    """Helper to fetch JSON files from raw Hugging Face branches."""
     try:
         response = requests.get(url, timeout=5)
         return response.json() if response.status_code == 200 else None
     except Exception as e:
-        logger.error(f"Error fetching metadata from {url}: {e}")
+        logger.error(f"Error fetching metadata: {e}")
         return None
 
 def load_all_assets(key: str) -> Dict:
-    """Fetch dataframe and metadata with memory caching."""
     if key not in _ASSET_CACHE:
-        logger.info(f"Loading assets for dataset: {key}")
-        # Load main parquet/csv data
         ds = load_dataset(REPO_CONFIG[key]["repo"])
-        # Fetch metadata from dedicated branches
-        meta = fetch_remote_json(REPO_CONFIG[key]["meta_url"])
-        report = fetch_remote_json(REPO_CONFIG[key]["report_url"])
-        
         _ASSET_CACHE[key] = {
             "df": pd.DataFrame(ds["train"]),
-            "meta": meta,
-            "report": report
+            "meta": fetch_remote_json(REPO_CONFIG[key]["meta_url"]),
+            "report": fetch_remote_json(REPO_CONFIG[key]["report_url"])
         }
     return _ASSET_CACHE[key]
 
-def generate_meta_markdown(assets: Dict) -> str:
-    """Parse JSON metadata into a human-readable research summary."""
+def generate_guide_markdown(assets: Dict) -> str:
     meta = assets.get("meta", {})
     params = meta.get("parameters", {})
     report = assets.get("report", {})
-    
-    if not meta:
-        return "⚠️ *Metadata currently unavailable for this dataset branch.*"
-    
-    # Format family distribution from report.json
+    if not meta: return "⚠️ *Metadata unavailable.*"
+
     families = report.get("families", {})
-    fam_info = ", ".join([f"{k.upper()}: {v}" for k, v in families.items()])
+    fam_table = "| Family | Samples | Description |\n| :--- | :--- | :--- |\n"
+    for f, count in families.items():
+        fam_table += f"| **{f.upper()}** | {count} | Synthetic {f} circuits |\n"
+
+    return f"""
+    ## 📖 Methodology & Release Notes: {meta.get('dataset_version', '1.0.0-demo')}
     
-    md = (
-        f"### 📋 Dataset Release: {meta.get('dataset_version', '1.0.0')}\n"
-        f"**Hardware Config:** {params.get('n_qubits')} Qubits | Depth: {params.get('depth')} | "
-        f"Shots: {params.get('shots')} | Device: {meta.get('backend_device', 'GPU')}\n\n"
-        f"**Noise Model:** `{params.get('noise', 'Clean')}` (p={params.get('noise_prob', 0.0)}) | "
-        f"**Circuit Coverage:** {fam_info}"
-    )
-    return md
+    ### 1. Generation Engine
+    Generated using **QSBench v{meta.get('generator_version', '5.0')}**.
+    - **Qubits:** {params.get('n_qubits')} | **Depth:** {params.get('depth')}
+    - **Noise:** `{params.get('noise', 'None')}` (p={params.get('noise_prob', 0)})
+    - **Backend:** {meta.get('backend_device', 'GPU')}
+
+    ### 2. Structural Metrics
+    * **Gate Entropy:** Distribution of gates.
+    * **Meyer-Wallach:** Global entanglement.
+
+    ### 3. Circuit Family Coverage
+    {fam_table}
+    """
 
 def update_explorer_view(ds_name: str, split_name: str):
-    """Main callback for the Explorer tab."""
     assets = load_all_assets(ds_name)
     df = assets["df"]
-    
     splits = df["split"].unique().tolist() if "split" in df.columns else ["train"]
     display_df = df[df["split"] == split_name].head(10) if "split" in df.columns else df.head(10)
-    
-    # QASM Sample Extraction
     raw_qasm = display_df["qasm_raw"].iloc[0] if "qasm_raw" in display_df.columns else "// No data"
     tr_qasm = display_df["qasm_transpiled"].iloc[0] if "qasm_transpiled" in display_df.columns else "// No data"
     
-    return gr.update(choices=splits), display_df, raw_qasm, tr_qasm, generate_meta_markdown(assets)
+    meta_summary = f"### 📋 Pack: {ds_name} | Release: {assets.get('meta', {}).get('dataset_version', 'N/A')}"
+    return gr.update(choices=splits), display_df, raw_qasm, tr_qasm, meta_summary, generate_guide_markdown(assets)
 
 def sync_ml_inputs(ds_name: str):
-    """Callback to update feature checkboxes when dataset changes."""
     assets = load_all_assets(ds_name)
     df = assets["df"]
-    
-    numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
-    valid_features = [c for c in numeric_cols if c not in NON_FEATURE_COLS and not c.startswith(("error_", "sign_", "ideal_", "noisy_"))]
-    
-    # Default selection of core structural metrics
-    top_picks = [f for f in ["gate_entropy", "meyer_wallach", "n_qubits", "depth", "total_gates"] if f in valid_features]
-    
-    return gr.update(choices=valid_features, value=top_picks or valid_features[:5])
+    numeric = df.select_dtypes(include=[np.number]).columns.tolist()
+    valid = [c for c in numeric if c not in NON_FEATURE_COLS and not c.startswith(("error_", "sign_", "ideal_", "noisy_"))]
+    top_picks = [f for f in ["gate_entropy", "meyer_wallach", "n_qubits", "depth"] if f in valid]
+    return gr.update(choices=valid, value=top_picks)
 
 def train_baseline_model(ds_name: str, selected_features: List[str]):
-    """Train a Random Forest regressor and generate analytics plots."""
-    if not selected_features:
-        return None, "### ❌ Error: Please select at least one feature."
-    
+    if not selected_features: return None, "### ❌ Error: Select features."
     assets = load_all_assets(ds_name)
     df = assets["df"]
     target = "ideal_expval_Z_global" if "ideal_expval_Z_global" in df.columns else df.filter(like="expval").columns[0]
-    
-    # Data cleaning
     train_df = df.dropna(subset=selected_features + [target])
-    if len(train_df) < 50:
-        return None, "### ⚠️ Warning: Dataset too small for reliable training."
-
     X, y = train_df[selected_features], train_df[target]
     X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-
-    # Model Pipeline
     model = RandomForestRegressor(n_estimators=100, max_depth=12, n_jobs=-1, random_state=42)
     model.fit(X_train, y_train)
     preds = model.predict(X_test)
-
-    # Plotting
-    sns.set_theme(style="whitegrid", context="notebook")
     fig, axes = plt.subplots(1, 3, figsize=(20, 6))
-    
-    # 1. Parity Plot
-    axes[0].scatter(y_test, preds, alpha=0.4, color='#34495e')
-    axes[0].plot([y.min(), y.max()], [y.min(), y.max()], 'r--', lw=2)
-    axes[0].set_title(f"Regression Accuracy (R²: {r2_score(y_test, preds):.3f})")
-    axes[0].set_xlabel("Actual")
-    axes[0].set_ylabel("Predicted")
-
-    # 2. Importance
-    importances = model.feature_importances_
-    indices = np.argsort(importances)[-12:]
-    axes[1].barh([selected_features[i] for i in indices], importances[indices], color='#1abc9c')
-    axes[1].set_title("Top Structural Predictors")
-
-    # 3. Error Analysis
-    sns.histplot(y_test - preds, kde=True, ax=axes[2], color='#e67e22')
-    axes[2].set_title("Residuals Distribution")
-
+    axes[0].scatter(y_test, preds, alpha=0.4); axes[0].plot([y.min(), y.max()], [y.min(), y.max()], 'r--')
+    axes[1].barh(selected_features[:10], model.feature_importances_[:10])
+    sns.histplot(y_test - preds, kde=True, ax=axes[2])
     plt.tight_layout()
-    result_text = f"**Model Performance on {ds_name}**\n**MAE:** {mean_absolute_error(y_test, preds):.4f}"
-    
-    return fig, result_text
-
-# --- GRADIO INTERFACE ---
+    return fig, f"**MAE:** {mean_absolute_error(y_test, preds):.4f}"
 
-with gr.Blocks(theme=gr.themes.Soft(), title="QSBench Analytics") as demo:
+# --- UI ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("# 🌌 QSBench: Quantum Synthetic Benchmark Suite")
     
     with gr.Tabs():
-        with gr.TabItem("🔎 Dataset Explorer"):
-            # Header with parsed metadata from JSON
-            metadata_box = gr.Markdown("### Synchronizing with Hugging Face...")
-            
+        with gr.TabItem("🔎 Explorer"):
+            metadata_box = gr.Markdown("### Syncing...")
             with gr.Row():
                 ds_select = gr.Dropdown(choices=list(REPO_CONFIG.keys()), value="Core (Clean)", label="Dataset Pack")
                 split_select = gr.Dropdown(choices=["train"], value="train", label="Subset")
-            
             data_table = gr.Dataframe(interactive=False)
-            
             with gr.Row():
-                code_raw = gr.Code(label="Source Circuit (QASM)", language="python")
-                code_tr = gr.Code(label="Transpiled (Hardware-Ready)", language="python")
+                code_raw = gr.Code(label="Source QASM", language="python")
+                code_tr = gr.Code(label="Transpiled QASM", language="python")
 
-        with gr.TabItem("🤖 ML Training Baseline"):
+        with gr.TabItem("🤖 ML Training"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    gr.Markdown("### Training Configuration")
-                    ml_ds_select = gr.Dropdown(choices=list(REPO_CONFIG.keys()), value="Core (Clean)", label="Source Dataset")
-                    ml_features = gr.CheckboxGroup(label="Structural Metrics", choices=[])
-                    btn_train = gr.Button("Execute Baseline Training", variant="primary")
+                    ml_ds = gr.Dropdown(choices=list(REPO_CONFIG.keys()), value="Core (Clean)", label="Dataset")
+                    ml_feat = gr.CheckboxGroup(label="Features", choices=[])
+                    btn = gr.Button("Train Baseline", variant="primary")
                 with gr.Column(scale=2):
-                    plot_output = gr.Plot()
-                    txt_output = gr.Markdown()
+                    plot_out = gr.Plot(); txt_out = gr.Markdown()
 
-    # Footer/Resources
-    gr.Markdown("""
+        with gr.TabItem("📖 Methodology & Guide"):
+            guide_md = gr.Markdown("Loading guide...")
+
+    # FOOTER WITH YOUR LINKS
+    gr.Markdown(f"""
     ---
-    ### 🔬 Research Credits
-    **QSBench** is an open-source framework for noise-aware Quantum Machine Learning benchmarking.
-    - [GitHub Repository](https://github.com/QSBench/QSBench-Demo) | [Official Website](https://qsbench.github.io)
+    ### 🔗 Project Resources & Store
+    * **🤗 Hugging Face:** [QSBench Organization](https://huggingface.co/QSBench)
+    * **💻 GitHub:** [QSBench Source Code](https://github.com/QSBench)
+    * **🌐 Official Site:** [qsbench.github.io](https://qsbench.github.io)
+    
+    *QSBench is an open-source framework for noise-aware Quantum Machine Learning benchmarking.*
     """)
 
-    # Event Handlers
-    ds_select.change(update_explorer_view, [ds_select, split_select], [split_select, data_table, code_raw, code_tr, metadata_box])
-    ml_ds_select.change(sync_ml_inputs, [ml_ds_select], [ml_features])
-    btn_train.click(train_baseline_model, [ml_ds_select, ml_features], [plot_output, txt_output])
+    ds_select.change(update_explorer_view, [ds_select, split_select], [split_select, data_table, code_raw, code_tr, metadata_box, guide_md])
+    ml_ds.change(sync_ml_inputs, [ml_ds], [ml_feat])
+    btn.click(train_baseline_model, [ml_ds, ml_feat], [plot_out, txt_out])
     
-    # Initial Load
-    demo.load(update_explorer_view, [ds_select, split_select], [split_select, data_table, code_raw, code_tr, metadata_box])
-    demo.load(sync_ml_inputs, [ml_ds_select], [ml_features])
+    demo.load(update_explorer_view, [ds_select, split_select], [split_select, data_table, code_raw, code_tr, metadata_box, guide_md])
+    demo.load(sync_ml_inputs, [ml_ds], [ml_feat])
 
 if __name__ == "__main__":
     demo.launch()