Upload conditional strength-focus diagnostics

evaluation/query_family/conditional/strength_focus/README.md

@@ -0,0 +1,19 @@
+# Strength Focus
+
+Strength-only conditional analysis artifacts.
+
+Files:
+
+- `overall_strength_by_model.csv`
+- `strength_support_bucket_summary.csv`
+- `strength_support_by_model.csv`
+- `fig_strength_overall_model_bars.png`
+- `fig_strength_support_bucket_summary.png`
+- `fig_strength_support_by_model.png`
+- `strength_focus_report.md`
+
+Generate / refresh:
+
+```bash
+python Evaluation/query_fivepart_breakdown/conditional_breakdown/strength_focus/generate_strength_focus.py
+```

evaluation/query_family/conditional/strength_focus/fig_strength_overall_model_bars.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:353cae0ea826b521ebb0b032ffd87aeec785038cac0636666038c838aeb55dd8
+size 19019

evaluation/query_family/conditional/strength_focus/fig_strength_support_bucket_summary.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6badf98aee1e280362012d390f625a873818b52210711b66d9521c7261709dde
+size 13309

evaluation/query_family/conditional/strength_focus/fig_strength_support_by_model.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb2d4ab340222cffde36380057774d0488e36f323b50da7f3ba2e79f001039e2
+size 17440

evaluation/query_family/conditional/strength_focus/generate_strength_focus.py

@@ -0,0 +1,330 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+
+ROOT = Path(__file__).resolve().parents[4]
+BASE = ROOT / "Evaluation" / "query_fivepart_breakdown" / "conditional_breakdown"
+OUT_DIR = BASE / "strength_focus"
+RUN_DIR = (
+    BASE
+    / "locality_support_diagnostics"
+    / "runs"
+    / "20260502_064421_conditional_locality_support"
+    / "data"
+)
+
+MODEL_COLORS = {
+    "RealTabFormer": "#332288",
+    "TVAE": "#4477AA",
+    "ForestDiffusion": "#228833",
+    "TabDDPM": "#EE7733",
+    "TabSyn": "#66CCEE",
+    "TabDiff": "#AA3377",
+    "CTGAN": "#EE6677",
+    "ARF": "#777777",
+    "BayesNet": "#CCBB44",
+    "TabPFGen": "#009988",
+    "TabbyFlow": "#882255",
+}
+
+SUPPORT_BUCKET_ORDER = ["dense", "medium", "sparse"]
+SUPPORT_BUCKET_LABELS = {"dense": "Dense", "medium": "Medium", "sparse": "Sparse"}
+SUPPORT_BUCKET_COLORS = {"dense": "#1b9e77", "medium": "#7570b3", "sparse": "#d95f02"}
+
+
+def _assign_primary_support_buckets(audit_df: pd.DataFrame) -> pd.DataFrame:
+    case_df = audit_df[
+        [
+            "dataset_id",
+            "query_id",
+            "real_support_value",
+            "support_main_eligible",
+            "support_recovery_mode",
+            "template_name",
+        ]
+    ].drop_duplicates()
+    eligible = case_df[
+        (case_df["support_main_eligible"] == True)
+        & (case_df["support_recovery_mode"].isin(["exact", "derived_exact"]))
+        & (case_df["real_support_value"].notna())
+    ].copy()
+
+    rows: list[pd.DataFrame] = []
+    for dataset_id, group in eligible.groupby("dataset_id", sort=False):
+        values = pd.to_numeric(group["real_support_value"], errors="coerce")
+        if group.shape[0] < 3 or values.dropna().nunique() < 3:
+            continue
+        ranked = values.rank(method="first")
+        bins = pd.qcut(ranked, q=3, labels=["sparse", "medium", "dense"])
+        assigned = group[["dataset_id", "query_id"]].copy()
+        assigned["support_bucket"] = bins.astype(str)
+        rows.append(assigned)
+    return pd.concat(rows, ignore_index=True)
+
+
+def _build_strength_tables() -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+    model_summary = pd.read_csv(BASE / "final" / "model_summary__v2.csv")
+    audit = pd.read_csv(RUN_DIR / "conditional_support_method_audit.csv")
+    bucket_map = _assign_primary_support_buckets(audit)
+
+    overall = model_summary[
+        [
+            "model_label",
+            "dataset_count",
+            "dependency_strength_similarity__mean",
+            "dependency_strength_similarity__ci95_low",
+            "dependency_strength_similarity__ci95_high",
+            "dependency_strength_similarity__ci95_radius",
+        ]
+    ].rename(
+        columns={
+            "dependency_strength_similarity__mean": "strength_mean",
+            "dependency_strength_similarity__ci95_low": "strength_ci95_low",
+            "dependency_strength_similarity__ci95_high": "strength_ci95_high",
+            "dependency_strength_similarity__ci95_radius": "strength_ci95_radius",
+        }
+    )
+    overall = overall.sort_values("strength_mean", ascending=False).reset_index(drop=True)
+
+    strength_rows = audit[audit["subitem_label"] == "Dependency strength similarity"].copy()
+    strength_rows = strength_rows.merge(bucket_map, on=["dataset_id", "query_id"], how="inner")
+
+    panel_strength = (
+        strength_rows.groupby(
+            ["dataset_id", "dataset_prefix", "model_label", "support_bucket"],
+            as_index=False,
+        )["query_score"]
+        .mean()
+        .rename(columns={"query_score": "panel_strength"})
+    )
+
+    bucket_summary = (
+        panel_strength.groupby("support_bucket", as_index=False)
+        .agg(
+            strength_mean=("panel_strength", "mean"),
+            strength_std=("panel_strength", "std"),
+            panel_count=("panel_strength", "count"),
+        )
+        .reset_index(drop=True)
+    )
+    bucket_summary["strength_se"] = bucket_summary["strength_std"] / np.sqrt(bucket_summary["panel_count"])
+    bucket_summary["strength_ci95_radius"] = 1.96 * bucket_summary["strength_se"]
+    bucket_summary["bucket_label"] = bucket_summary["support_bucket"].map(SUPPORT_BUCKET_LABELS)
+    bucket_summary["support_bucket"] = pd.Categorical(
+        bucket_summary["support_bucket"], SUPPORT_BUCKET_ORDER, ordered=True
+    )
+    bucket_summary = bucket_summary.sort_values("support_bucket").reset_index(drop=True)
+
+    model_bucket = (
+        panel_strength.groupby(["model_label", "support_bucket"], as_index=False)["panel_strength"]
+        .mean()
+        .rename(columns={"panel_strength": "strength_mean"})
+    )
+    model_bucket["bucket_label"] = model_bucket["support_bucket"].map(SUPPORT_BUCKET_LABELS)
+    pivot = model_bucket.pivot(index="model_label", columns="support_bucket", values="strength_mean").reset_index()
+    for bucket in SUPPORT_BUCKET_ORDER:
+        if bucket not in pivot.columns:
+            pivot[bucket] = np.nan
+    pivot["range"] = pivot[SUPPORT_BUCKET_ORDER].max(axis=1) - pivot[SUPPORT_BUCKET_ORDER].min(axis=1)
+    pivot = pivot.sort_values("dense", ascending=False).reset_index(drop=True)
+
+    return overall, bucket_summary, model_bucket, pivot
+
+
+def _plot_overall_strength(overall: pd.DataFrame) -> None:
+    fig, ax = plt.subplots(figsize=(11, 6))
+    x = np.arange(len(overall))
+    colors = [MODEL_COLORS.get(model, "#999999") for model in overall["model_label"]]
+    ax.bar(x, overall["strength_mean"], color=colors, edgecolor="black", linewidth=0.5)
+    ax.errorbar(
+        x,
+        overall["strength_mean"],
+        yerr=overall["strength_ci95_radius"],
+        fmt="none",
+        ecolor="black",
+        elinewidth=1,
+        capsize=3,
+    )
+    ax.set_xticks(x)
+    ax.set_xticklabels(overall["model_label"], rotation=45, ha="right")
+    ax.set_ylabel("Dependency strength similarity")
+    ax.set_title("Overall conditional strength by model")
+    ax.set_ylim(0, 0.8)
+    ax.grid(axis="y", alpha=0.25)
+    fig.tight_layout()
+    fig.savefig(OUT_DIR / "fig_strength_overall_model_bars.png", dpi=220)
+    fig.savefig(OUT_DIR / "fig_strength_overall_model_bars.pdf")
+    plt.close(fig)
+
+
+def _plot_strength_bucket_summary(bucket_summary: pd.DataFrame) -> None:
+    fig, ax = plt.subplots(figsize=(7, 5))
+    x = np.arange(len(bucket_summary))
+    colors = [SUPPORT_BUCKET_COLORS[b] for b in bucket_summary["support_bucket"].astype(str)]
+    ax.bar(x, bucket_summary["strength_mean"], color=colors, edgecolor="black", linewidth=0.6)
+    ax.errorbar(
+        x,
+        bucket_summary["strength_mean"],
+        yerr=bucket_summary["strength_ci95_radius"],
+        fmt="none",
+        ecolor="black",
+        elinewidth=1,
+        capsize=4,
+    )
+    ax.set_xticks(x)
+    ax.set_xticklabels(bucket_summary["bucket_label"])
+    ax.set_ylabel("Dependency strength similarity")
+    ax.set_title("Conditional strength by support bucket")
+    ax.set_ylim(0, 0.45)
+    ax.grid(axis="y", alpha=0.25)
+    fig.tight_layout()
+    fig.savefig(OUT_DIR / "fig_strength_support_bucket_summary.png", dpi=220)
+    fig.savefig(OUT_DIR / "fig_strength_support_bucket_summary.pdf")
+    plt.close(fig)
+
+
+def _plot_strength_by_model_bucket(model_bucket_pivot: pd.DataFrame) -> None:
+    models = model_bucket_pivot["model_label"].tolist()
+    x = np.arange(len(models))
+    width = 0.23
+
+    fig, ax = plt.subplots(figsize=(12, 6))
+    for idx, bucket in enumerate(SUPPORT_BUCKET_ORDER):
+        offset = (idx - 1) * width
+        ax.bar(
+            x + offset,
+            model_bucket_pivot[bucket],
+            width=width,
+            label=SUPPORT_BUCKET_LABELS[bucket],
+            color=SUPPORT_BUCKET_COLORS[bucket],
+            edgecolor="black",
+            linewidth=0.4,
+        )
+
+    ax.set_xticks(x)
+    ax.set_xticklabels(models, rotation=45, ha="right")
+    ax.set_ylabel("Dependency strength similarity")
+    ax.set_title("Conditional strength by model and support bucket")
+    ax.set_ylim(0, 0.45)
+    ax.grid(axis="y", alpha=0.25)
+    ax.legend(frameon=False, ncol=3, loc="upper center")
+    fig.tight_layout()
+    fig.savefig(OUT_DIR / "fig_strength_support_by_model.png", dpi=220)
+    fig.savefig(OUT_DIR / "fig_strength_support_by_model.pdf")
+    plt.close(fig)
+
+
+def _write_report(
+    overall: pd.DataFrame,
+    bucket_summary: pd.DataFrame,
+    model_bucket_pivot: pd.DataFrame,
+) -> None:
+    top = overall.iloc[0]
+    bottom = overall.iloc[-1]
+    dense = bucket_summary.loc[bucket_summary["support_bucket"].astype(str) == "dense", "strength_mean"].iloc[0]
+    medium = bucket_summary.loc[bucket_summary["support_bucket"].astype(str) == "medium", "strength_mean"].iloc[0]
+    sparse = bucket_summary.loc[bucket_summary["support_bucket"].astype(str) == "sparse", "strength_mean"].iloc[0]
+    flat = model_bucket_pivot.sort_values("range").head(3)
+    volatile = model_bucket_pivot.sort_values("range", ascending=False).head(3)
+
+    report = f"""# Strength-Only Conditional Analysis
+
+## Scope
+
+- Focus metric: `dependency_strength_similarity`
+- Overall source: `final/model_summary__v2.csv`
+- Support-bucket source: `locality_support_diagnostics/runs/20260502_064421_conditional_locality_support`
+- Primary support variant: `scalar_filtered_local`
+
+## What this isolates
+
+This bundle ignores `direction_consistency` and `slice_level_consistency` and asks only one question:
+
+> When the real data contains a conditional relationship, does the synthetic data preserve how *strong* that relationship is?
+
+In downstream terms, this matters for tasks such as:
+
+- deciding which conditional signals look strongest and therefore most actionable
+- ranking features, slices, or segments by how tightly they track an outcome
+- screening for candidate interactions before deeper local analysis
+
+If strength is distorted, a downstream analyst may still see the right columns and the right report shape, but mis-rank which relationships deserve attention.
+
+## Main findings
+
+1. Overall model spread is real but not huge: the top model is `{top['model_label']}` at `{top['strength_mean']:.3f}`, while the weakest is `{bottom['model_label']}` at `{bottom['strength_mean']:.3f}`.
+2. In the primary scalar filtered-local subset, support buckets are close: dense=`{dense:.3f}`, medium=`{medium:.3f}`, sparse=`{sparse:.3f}`.
+3. This means strength does **not** show a clean sparse-support penalty in the current main support diagnostic.
+4. Several models are almost flat across support buckets, especially:
+   - `{flat.iloc[0]['model_label']}` range=`{flat.iloc[0]['range']:.3f}`
+   - `{flat.iloc[1]['model_label']}` range=`{flat.iloc[1]['range']:.3f}`
+   - `{flat.iloc[2]['model_label']}` range=`{flat.iloc[2]['range']:.3f}`
+5. The most bucket-sensitive models still do not follow one universal direction:
+   - `{volatile.iloc[0]['model_label']}` range=`{volatile.iloc[0]['range']:.3f}`
+   - `{volatile.iloc[1]['model_label']}` range=`{volatile.iloc[1]['range']:.3f}`
+   - `{volatile.iloc[2]['model_label']}` range=`{volatile.iloc[2]['range']:.3f}`
+
+## Downstream interpretation
+
+- Broad implication: many generators change conditional-strength estimates less across dense/medium/sparse local slices than one might expect. The support size of the slice is therefore not the main explanation for strength distortion.
+- Practical implication: if a downstream user relies on synthetic data to decide *which* conditional relationships are strongest, the bigger risk is model-specific calibration of strength, not simply sparse local support.
+- Reading by model family:
+  - `RealTabFormer` is strong overall and also stable across buckets, which makes it the cleanest strength-preserving model in the current panel.
+  - `BayesNet`, `ARF`, and `CTGAN` are comparatively flat across buckets, suggesting that for these models the strength story is more about their overall calibration level than about sensitivity to sparse slices.
+  - `TVAE`, `TabbyFlow`, and `TabSyn` vary more by bucket, but even there the movement is not monotonic dense-to-sparse collapse.
+
+## Applicability note
+
+The primary `Dense / Medium / Sparse` analysis is **not** a universal conditional-family split.
+It applies only to filtered-local templates whose support can be defined as a scalar real row count:
+
+- `Filtered Median Numeric Slice`
+- `Filtered Sum in Numeric Band`
+
+`Filtered Two-Dimensional Group Count` is excluded from the main bucket claim because its natural support object is a per-cell count distribution rather than one scalar filtered-row count.
+"""
+    (OUT_DIR / "strength_focus_report.md").write_text(report, encoding="utf-8")
+
+    readme = """# Strength Focus
+
+Strength-only conditional analysis artifacts.
+
+Files:
+
+- `overall_strength_by_model.csv`
+- `strength_support_bucket_summary.csv`
+- `strength_support_by_model.csv`
+- `fig_strength_overall_model_bars.png`
+- `fig_strength_support_bucket_summary.png`
+- `fig_strength_support_by_model.png`
+- `strength_focus_report.md`
+
+Generate / refresh:
+
+```bash
+python Evaluation/query_fivepart_breakdown/conditional_breakdown/strength_focus/generate_strength_focus.py
+```
+"""
+    (OUT_DIR / "README.md").write_text(readme, encoding="utf-8")
+
+
+def main() -> None:
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+    overall, bucket_summary, model_bucket, model_bucket_pivot = _build_strength_tables()
+    overall.to_csv(OUT_DIR / "overall_strength_by_model.csv", index=False)
+    bucket_summary.to_csv(OUT_DIR / "strength_support_bucket_summary.csv", index=False)
+    model_bucket_pivot.to_csv(OUT_DIR / "strength_support_by_model.csv", index=False)
+    model_bucket.to_csv(OUT_DIR / "strength_support_by_model_long.csv", index=False)
+    _plot_overall_strength(overall)
+    _plot_strength_bucket_summary(bucket_summary)
+    _plot_strength_by_model_bucket(model_bucket_pivot)
+    _write_report(overall, bucket_summary, model_bucket_pivot)
+
+
+if __name__ == "__main__":
+    main()

evaluation/query_family/conditional/strength_focus/overall_strength_by_model.csv

@@ -0,0 +1,12 @@
+model_label,dataset_count,strength_mean,strength_ci95_low,strength_ci95_high,strength_ci95_radius
+RealTabFormer,45,0.595599,0.541776,0.649421,0.053823
+TabDiff,16,0.583062,0.455911,0.710212,0.12715
+TabPFGen,38,0.503638,0.421703,0.585573,0.081935
+BayesNet,49,0.495104,0.428611,0.561597,0.066493
+ARF,49,0.483505,0.412391,0.554619,0.071114
+CTGAN,47,0.468992,0.399782,0.538203,0.069211
+TVAE,48,0.446857,0.377867,0.515847,0.06899
+TabbyFlow,31,0.446402,0.35511,0.537693,0.091291
+TabDDPM,38,0.338094,0.264066,0.412121,0.074027
+TabSyn,45,0.320368,0.255435,0.385301,0.064933
+ForestDiffusion,26,0.293929,0.204667,0.38319,0.089262

evaluation/query_family/conditional/strength_focus/strength_focus_report.md

@@ -0,0 +1,55 @@
+# Strength-Only Conditional Analysis
+
+## Scope
+
+- Focus metric: `dependency_strength_similarity`
+- Overall source: `final/model_summary__v2.csv`
+- Support-bucket source: `locality_support_diagnostics/runs/20260502_064421_conditional_locality_support`
+- Primary support variant: `scalar_filtered_local`
+
+## What this isolates
+
+This bundle ignores `direction_consistency` and `slice_level_consistency` and asks only one question:
+
+> When the real data contains a conditional relationship, does the synthetic data preserve how *strong* that relationship is?
+
+In downstream terms, this matters for tasks such as:
+
+- deciding which conditional signals look strongest and therefore most actionable
+- ranking features, slices, or segments by how tightly they track an outcome
+- screening for candidate interactions before deeper local analysis
+
+If strength is distorted, a downstream analyst may still see the right columns and the right report shape, but mis-rank which relationships deserve attention.
+
+## Main findings
+
+1. Overall model spread is real but not huge: the top model is `RealTabFormer` at `0.596`, while the weakest is `ForestDiffusion` at `0.294`.
+2. In the primary scalar filtered-local subset, support buckets are close: dense=`0.300`, medium=`0.285`, sparse=`0.289`.
+3. This means strength does **not** show a clean sparse-support penalty in the current main support diagnostic.
+4. Several models are almost flat across support buckets, especially:
+   - `ForestDiffusion` range=`0.000`
+   - `TabPFGen` range=`0.000`
+   - `RealTabFormer` range=`0.001`
+5. The most bucket-sensitive models still do not follow one universal direction:
+   - `TVAE` range=`0.119`
+   - `TabDiff` range=`0.067`
+   - `TabbyFlow` range=`0.063`
+
+## Downstream interpretation
+
+- Broad implication: many generators change conditional-strength estimates less across dense/medium/sparse local slices than one might expect. The support size of the slice is therefore not the main explanation for strength distortion.
+- Practical implication: if a downstream user relies on synthetic data to decide *which* conditional relationships are strongest, the bigger risk is model-specific calibration of strength, not simply sparse local support.
+- Reading by model family:
+  - `RealTabFormer` is strong overall and also stable across buckets, which makes it the cleanest strength-preserving model in the current panel.
+  - `BayesNet`, `ARF`, and `CTGAN` are comparatively flat across buckets, suggesting that for these models the strength story is more about their overall calibration level than about sensitivity to sparse slices.
+  - `TVAE`, `TabbyFlow`, and `TabSyn` vary more by bucket, but even there the movement is not monotonic dense-to-sparse collapse.
+
+## Applicability note
+
+The primary `Dense / Medium / Sparse` analysis is **not** a universal conditional-family split.
+It applies only to filtered-local templates whose support can be defined as a scalar real row count:
+
+- `Filtered Median Numeric Slice`
+- `Filtered Sum in Numeric Band`
+
+`Filtered Two-Dimensional Group Count` is excluded from the main bucket claim because its natural support object is a per-cell count distribution rather than one scalar filtered-row count.

evaluation/query_family/conditional/strength_focus/strength_support_bucket_summary.csv

@@ -0,0 +1,4 @@
+support_bucket,strength_mean,strength_std,panel_count,strength_se,strength_ci95_radius,bucket_label
+dense,0.29968847352024924,0.22754938710139427,214,0.015554955872560056,0.030487713510217708,Dense
+medium,0.28484848484848485,0.22162414027366736,231,0.014581797873706105,0.028580323832463964,Medium
+sparse,0.28879184861717616,0.19719165198754085,229,0.013030791148783387,0.02554035065161544,Sparse

evaluation/query_family/conditional/strength_focus/strength_support_by_model.csv

@@ -0,0 +1,12 @@
+model_label,dense,medium,sparse,range
+RealTabFormer,0.42424242424242425,0.424,0.425,0.0010000000000000009
+TabSyn,0.3490196078431373,0.37777777777777777,0.4,0.05098039215686273
+TVAE,0.33333333333333337,0.21481481481481485,0.291358024691358,0.11851851851851852
+CTGAN,0.31733333333333336,0.25925925925925924,0.25679012345679014,0.060543209876543214
+TabbyFlow,0.30833333333333335,0.29411764705882354,0.3568627450980392,0.06274509803921569
+ARF,0.29743589743589743,0.27142857142857146,0.2547619047619048,0.04267399267399263
+BayesNet,0.27179487179487183,0.2857142857142857,0.2380952380952381,0.04761904761904759
+TabDDPM,0.26666666666666666,0.3166666666666667,0.275,0.050000000000000044
+ForestDiffusion,0.20000000000000004,0.2,0.2,2.7755575615628914e-17
+TabDiff,0.2,0.2,0.26666666666666666,0.06666666666666665
+TabPFGen,0.2,0.20000000000000004,0.20000000000000004,2.7755575615628914e-17

evaluation/query_family/conditional/strength_focus/strength_support_by_model_long.csv

@@ -0,0 +1,34 @@
+model_label,support_bucket,strength_mean,bucket_label
+ARF,dense,0.29743589743589743,Dense
+ARF,medium,0.27142857142857146,Medium
+ARF,sparse,0.2547619047619048,Sparse
+BayesNet,dense,0.27179487179487183,Dense
+BayesNet,medium,0.2857142857142857,Medium
+BayesNet,sparse,0.2380952380952381,Sparse
+CTGAN,dense,0.31733333333333336,Dense
+CTGAN,medium,0.25925925925925924,Medium
+CTGAN,sparse,0.25679012345679014,Sparse
+ForestDiffusion,dense,0.20000000000000004,Dense
+ForestDiffusion,medium,0.2,Medium
+ForestDiffusion,sparse,0.2,Sparse
+RealTabFormer,dense,0.42424242424242425,Dense
+RealTabFormer,medium,0.424,Medium
+RealTabFormer,sparse,0.425,Sparse
+TVAE,dense,0.33333333333333337,Dense
+TVAE,medium,0.21481481481481485,Medium
+TVAE,sparse,0.291358024691358,Sparse
+TabDDPM,dense,0.26666666666666666,Dense
+TabDDPM,medium,0.3166666666666667,Medium
+TabDDPM,sparse,0.275,Sparse
+TabDiff,dense,0.2,Dense
+TabDiff,medium,0.2,Medium
+TabDiff,sparse,0.26666666666666666,Sparse
+TabPFGen,dense,0.2,Dense
+TabPFGen,medium,0.20000000000000004,Medium
+TabPFGen,sparse,0.20000000000000004,Sparse
+TabSyn,dense,0.3490196078431373,Dense
+TabSyn,medium,0.37777777777777777,Medium
+TabSyn,sparse,0.4,Sparse
+TabbyFlow,dense,0.30833333333333335,Dense
+TabbyFlow,medium,0.29411764705882354,Medium
+TabbyFlow,sparse,0.3568627450980392,Sparse