chore: update demo for v0.10.0 — new encoders, Audit tab, barren plateau badge, rff fix

app.py

@@ -1,4 +1,4 @@
-"""QuPrep — HuggingFace Spaces demo  (v0.8.0)"""
+"""QuPrep — HuggingFace Spaces demo  (v0.10.0)"""
 
 from __future__ import annotations
 
@@ -89,14 +89,15 @@ SAMPLES = {
 # ---------------------------------------------------------------------------
 
 ENCODINGS = [
-    "angle", "entangled_angle", "amplitude", "basis", "iqp",
+    "angle", "entangled_angle", "dense_angle", "amplitude", "basis", "iqp",
     "reupload", "hamiltonian", "zz_feature_map", "pauli_feature_map",
-    "random_fourier", "tensor_product", "qaoa_problem",
+    "random_fourier", "tensor_product", "qaoa_problem", "discretized",
 ]
 
 ENCODING_DESC = {
     "angle":            "Ry/Rx/Rz rotation per feature. NISQ-safe, depth O(1).",
     "entangled_angle":  "Rotation + CNOT entangling layers. NISQ-safe.",
+    "dense_angle":      "Ry+Rz per qubit — 2 features per qubit, halves qubit count vs angle. New in v0.10.",
     "amplitude":        "Feature vector as quantum state amplitudes. Qubit-efficient.",
     "basis":            "Binary features encoded as X gates. NISQ-safe.",
     "iqp":              "Havlíček ZZ feature map. Good for kernel methods.",
@@ -107,8 +108,28 @@ ENCODING_DESC = {
     "random_fourier":   "RBF kernel approximation via random Fourier features.",
     "tensor_product":   "Ry+Rz per qubit — full Bloch sphere, qubit-efficient.",
     "qaoa_problem":     "QAOA-inspired feature map. Features as cost Hamiltonian parameters.",
+    "discretized":      "Continuous → binary string with configurable precision. QUBO-ready. New in v0.10.",
 }
 
+# Shared encoder name → class map (used by Convert, Audit, Fingerprint)
+def _get_enc_map(qd):
+    return {
+        "angle":             qd.AngleEncoder,
+        "entangled_angle":   qd.EntangledAngleEncoder,
+        "dense_angle":       qd.DenseAngleEncoder,
+        "amplitude":         qd.AmplitudeEncoder,
+        "basis":             qd.BasisEncoder,
+        "iqp":               qd.IQPEncoder,
+        "reupload":          qd.ReUploadEncoder,
+        "hamiltonian":       qd.HamiltonianEncoder,
+        "zz_feature_map":    qd.ZZFeatureMapEncoder,
+        "pauli_feature_map": qd.PauliFeatureMapEncoder,
+        "random_fourier":    qd.RandomFourierEncoder,
+        "tensor_product":    qd.TensorProductEncoder,
+        "qaoa_problem":      qd.QAOAProblemEncoder,
+        "discretized":       qd.DiscretizedEncoder,
+    }
+
 FRAMEWORKS = ["qasm", "qiskit", "pennylane", "cirq", "tket", "braket", "qsharp", "iqm"]
 
 TASKS = ["classification", "regression", "kernel", "qaoa", "simulation"]
@@ -197,39 +218,9 @@ def _get_exporter(framework: str):
     return _map.get(framework, _map["qasm"])()
 
 def _prepare_rff(X_full, X_slice, framework):
-    """Manually fit RandomFourierEncoder on full data and encode/export the slice."""
-    from quprep.encode.random_fourier import RandomFourierEncoder
-    from quprep.core.dataset import Dataset
-    enc = RandomFourierEncoder()
-    enc.fit(X_full)
-    ds = Dataset(data=X_slice,
-                 feature_names=[f"f{i}" for i in range(X_slice.shape[1])],
-                 feature_types=["continuous"] * X_slice.shape[1],
-                 metadata={})
-    encoded_list = enc.encode_batch(ds)
-    exporter = _get_exporter(framework)
-    circuits = [exporter.export(e) for e in encoded_list]
-
-    from quprep.validation.cost import CostEstimate
-    n_qubits = enc.n_components
-    cost = CostEstimate(
-        encoding="random_fourier",
-        n_features=X_slice.shape[1],
-        n_qubits=n_qubits,
-        gate_count=n_qubits,
-        circuit_depth=1,
-        two_qubit_gates=0,
-        nisq_safe=True,
-        warning=None,
-    )
-
-    class _FakeResult:
-        pass
-    r = _FakeResult()
-    r.circuits = circuits
-    r.encoded = encoded_list
-    r.cost = cost
-    return r
+    """v0.10.0: RandomFourierEncoder is now auto-fit by Pipeline — plain prepare() works."""
+    import quprep as qd
+    return qd.prepare(X_slice, encoding="random_fourier", framework=framework), None
 
 def _reducer_kwargs(X_slice, X_full, n_qubits):
     """Return (kwargs_dict, clamp_note) — applies PCA reducer if budget < n_features.
@@ -247,7 +238,7 @@ def _encode_tabular(X, encoding, framework, n_samples, n_qubits):
     import quprep as qd
     X_slice = X[:max(1, n_samples)]
     if encoding == "random_fourier":
-        return _prepare_rff(X, X_slice, framework), None
+        return _prepare_rff(X, X_slice, framework)
     kw, note = _reducer_kwargs(X_slice, X, n_qubits)
     return qd.prepare(X_slice, encoding=encoding, framework=framework, **kw), note
 
@@ -255,7 +246,7 @@ def _encode_image(X, encoding, framework, n_samples, n_qubits=0):
     import quprep as qd
     X_slice = X[:max(1, n_samples)]
     if encoding == "random_fourier":
-        return _prepare_rff(X, X_slice, framework), None
+        return _prepare_rff(X, X_slice, framework)
     kw, note = _reducer_kwargs(X_slice, X, n_qubits)
     return qd.prepare(X_slice, encoding=encoding, framework=framework, **kw), note
 
@@ -269,7 +260,7 @@ def _encode_timeseries(X, encoding, framework, n_samples, n_qubits=0, window=4):
     X_win = ds_win.data
     X_slice = X_win[:max(1, n_samples)]
     if encoding == "random_fourier":
-        return _prepare_rff(X_win, X_slice, framework), None
+        return _prepare_rff(X_win, X_slice, framework)
     kw, note = _reducer_kwargs(X_slice, X_win, n_qubits)
     return qd.prepare(X_slice, encoding=encoding, framework=framework, **kw), note
 
@@ -279,7 +270,7 @@ def _encode_text(sentences, encoding, framework, n_qubits=0):
     dataset = TextIngester(method="tfidf", max_features=8).load(sentences)
     X = dataset.data
     if encoding == "random_fourier":
-        return _prepare_rff(X, X, framework), None
+        return _prepare_rff(X, X, framework)
     kw, note = _reducer_kwargs(X, X, n_qubits)
     return qd.prepare(X, encoding=encoding, framework=framework, **kw), note
 
@@ -404,6 +395,26 @@ def run_convert(source, csv_file, sample_name, hf_name, hf_split,
   </div>{warn}
 </div>"""
 
+    # Barren plateau badge (tabular/image/timeseries only, silent on error)
+    if X_num.ndim == 2 and X_num.size > 0 and dtype not in ("graph", "text"):
+        try:
+            from quprep.core.dataset import Dataset as _DS
+            _bp = qd.detect_barren_plateau(
+                _get_enc_map(qd).get(encoding, qd.AngleEncoder)(),
+                _DS(data=X_num[:5]),
+                cost_type="local",
+            )
+            _col = {"none": "#4ade80", "mild": "#fbbf24",
+                    "high": "#fb923c", "severe": "#f87171"}.get(_bp.risk_level, "#94a3b8")
+            cost_html += f"""
+<div style="margin-top:10px;padding:8px 14px;background:#1e293b;border-radius:8px">
+  <span style="color:#94a3b8;font-size:0.78rem">Barren plateau</span>
+  <span style="float:right;color:{_col};font-weight:700;font-size:0.85rem">{_bp.risk_level.upper()}</span>
+  <div style="clear:both;color:#64748b;font-size:0.72rem;margin-top:2px">depth {_bp.circuit_depth} · {_bp.n_qubits} qubits</div>
+</div>"""
+        except Exception:
+            pass
+
     n_circ = len(circuits)
     shape = f"{X_num.shape[0]}×{X_num.shape[1]}" if X_num.ndim == 2 else str(len(X))
     status = f"✓  {dtype} · {shape} → {n_circ} circuit(s) | showing sample 0"
@@ -595,6 +606,54 @@ def run_suggest(source, csv_file, sample_name, hf_name, hf_split, task, max_qubi
 # Fingerprint
 # ---------------------------------------------------------------------------
 
+def run_audit(source, csv_file, sample_name, hf_name, hf_split, encoding, qubit_budget):
+    """preprocessing_report() — structured dataset audit before encoding."""
+    try:
+        import quprep as qd
+        dtype, X, cols = load_data(source, csv_file, sample_name, hf_name, hf_split)
+    except Exception as exc:
+        return f"<p style='color:#f87171'>❌ {exc}</p>"
+
+    if dtype != "tabular":
+        return "<p style='color:#fbbf24'>⚠️ Audit works on tabular data only.</p>"
+
+    try:
+        ds = qd.NumpyIngester().load(X)
+        enc = _get_enc_map(qd).get(encoding, qd.AngleEncoder)()
+        budget = int(qubit_budget) if qubit_budget > 0 else X.shape[1]
+        report = qd.preprocessing_report(ds, encoder=enc, qubit_budget=budget)
+    except Exception as exc:
+        return f"<p style='color:#f87171'>❌ {exc}</p>"
+
+    sev_color = "#4ade80" if report.n_issues == 0 else ("#fbbf24" if report.n_issues <= 2 else "#f87171")
+    recs_html = "".join(
+        f"<li style='margin:4px 0;color:#cbd5e1;font-size:0.85rem'>{r}</li>"
+        for r in report.recommendations
+    ) if report.recommendations else "<li style='color:#4ade80'>No issues — data looks healthy.</li>"
+
+    return f"""
+<div style="font-family:sans-serif;font-size:0.9rem;line-height:1.6">
+  <div style="display:flex;align-items:center;gap:12px;margin-bottom:16px">
+    <span style="font-size:2rem;font-weight:700;color:{sev_color}">{report.n_issues}</span>
+    <span style="color:#94a3b8">issue(s) found · encoding={encoding} · qubit budget={budget}</span>
+  </div>
+  <div style="background:#1e293b;border-radius:8px;padding:14px 18px">
+    <div style="color:#64748b;font-size:0.78rem;font-weight:600;margin-bottom:8px;text-transform:uppercase;letter-spacing:.05em">Recommendations</div>
+    <ul style="margin:0;padding-left:18px">{recs_html}</ul>
+  </div>
+  <div style="display:grid;grid-template-columns:1fr 1fr;gap:8px;margin-top:12px">
+    <div style="background:#1e293b;border-radius:8px;padding:10px 14px">
+      <div style="color:#64748b;font-size:0.78rem">Shape</div>
+      <div style="font-weight:600">{X.shape[0]} × {X.shape[1]}</div>
+    </div>
+    <div style="background:#1e293b;border-radius:8px;padding:10px 14px">
+      <div style="color:#64748b;font-size:0.78rem">Encoder</div>
+      <div style="font-weight:600">{encoding}</div>
+    </div>
+  </div>
+</div>"""
+
+
 def run_fingerprint(source, csv_file, sample_name, hf_name, hf_split,
                     encoding, framework, reducer_type, n_components, n_qubits,
                     use_scaler, scaler_strategy,
@@ -607,21 +666,7 @@ def run_fingerprint(source, csv_file, sample_name, hf_name, hf_split,
         if dtype not in ("tabular", "image", "timeseries"):
             return "", "<p style='color:#fbbf24'>⚠️ Fingerprinting works on numeric data (tabular / image / time series).</p>"
         X_use = X
-        _enc_map = {
-            "angle":             qd.AngleEncoder,
-            "amplitude":         qd.AmplitudeEncoder,
-            "basis":             qd.BasisEncoder,
-            "iqp":               qd.IQPEncoder,
-            "entangled_angle":   qd.EntangledAngleEncoder,
-            "reupload":          qd.ReUploadEncoder,
-            "hamiltonian":       qd.HamiltonianEncoder,
-            "zz_feature_map":    qd.ZZFeatureMapEncoder,
-            "pauli_feature_map": qd.PauliFeatureMapEncoder,
-            "random_fourier":    qd.RandomFourierEncoder,
-            "tensor_product":    qd.TensorProductEncoder,
-            "qaoa_problem":      qd.QAOAProblemEncoder,
-        }
-        encoder_cls = _enc_map.get(encoding, qd.AngleEncoder)
+        encoder_cls = _get_enc_map(qd).get(encoding, qd.AngleEncoder)
         encoder = encoder_cls()
         if hasattr(encoder, "fit"):
             encoder.fit(X_use)
@@ -743,7 +788,7 @@ with gr.Blocks(title="QuPrep — Quantum Data Preparation") as demo:
         with gr.Column(scale=1, elem_id="header-left"):
             gr.HTML("""
 <p style="margin:0 0 2px;font-size:1.5rem;font-weight:700;color:#e2e8f0">⚛️ QuPrep</p>
-<p style="margin:0 0 14px;font-size:0.9rem;font-weight:500;color:#a78bfa">v0.8.0 · Quantum Data Preparation</p>
+<p style="margin:0 0 14px;font-size:0.9rem;font-weight:500;color:#a78bfa">v0.10.0 · Quantum Data Preparation</p>
 <p style="margin:0 0 14px;font-size:0.85rem;color:#94a3b8;line-height:1.6">
   The missing preprocessing layer between classical datasets and quantum computing.
 </p>
@@ -898,6 +943,22 @@ with gr.Blocks(title="QuPrep — Quantum Data Preparation") as demo:
 
             sug_btn.click(fn=_sug, inputs=_inputs(sug_task, sug_max), outputs=sug_out)
 
+        # Audit ────────────────────────────────────────────────────────────
+        with gr.TabItem("Audit"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    aud_enc = gr.Dropdown(choices=ENCODINGS, value="angle", label="Target encoding")
+                    aud_qsl = gr.Slider(0, 30, value=0, step=1, label="Qubit budget (0 = n_features)")
+                    aud_btn = gr.Button("Audit →", variant="primary")
+                    gr.HTML('<p style="font-size:0.82rem;color:#475569;margin:8px 0">Checks NaN, outliers, qubit budget, class imbalance, and encoder compatibility before you encode. Tabular data only.</p>')
+                with gr.Column(scale=3):
+                    aud_out = gr.HTML(value="<p style='color:#475569;padding:24px 0'>Click <strong>Audit →</strong></p>")
+
+            def _aud(src, csv, samp, hfn, hfs, enc, nq):
+                return run_audit(_src(src), csv, samp, hfn, hfs, enc, nq)
+
+            aud_btn.click(fn=_aud, inputs=_inputs(aud_enc, aud_qsl), outputs=aud_out)
+
         # Fingerprint ──────────────────────────────────────────────────────
         with gr.TabItem("Fingerprint"):
             with gr.Row():
@@ -974,12 +1035,14 @@ Connect → Ingest → Clean → Reduce → Normalise → Encode → Export
 Supports tabular, image, time series, graph, and text data.
 Data connectors: HuggingFace Hub, OpenML, Kaggle, CSV/NumPy upload.
 
-### Supported encodings (13)
+### Supported encodings (15)
 | Encoding | Qubits | NISQ-safe |
 |---|---|---|
 | Angle | d | ✓ |
+| Dense Angle *(v0.10)* | ⌈d/2⌉ | ✓ |
 | Amplitude | ⌈log₂d⌉ | ✗ |
 | Basis | d | ✓ |
+| Discretized *(v0.10)* | d×bits | ✓ |
 | IQP | d | conditional |
 | Entangled Angle | d | ✓ |
 | Re-Upload | d | ✓ |

requirements.txt

@@ -1,4 +1,4 @@
-quprep[qiskit,pennylane,cirq,tket,braket,qsharp,viz,huggingface,openml,image,text]>=0.8.0
+quprep[qiskit,pennylane,cirq,tket,braket,qsharp,viz,huggingface,openml,image,text]==0.10.0
 gradio>=4.0
 pandas
 numpy