Add interactive dataset and feature exploration

app.py

@@ -67,20 +67,22 @@ DISPLAY_NAMES = {
     "xg": "XGBoost",
 }
 
+# Canonical dataset names from manuscript v7, Supplementary Table 1. Task names
+# belong in descriptions, not in alternate dataset labels.
 DATASET_LABELS = {
     "monkey": "Macaque center-out reaching",
-    "allen_neuropixels": "Allen visual coding",
+    "allen_neuropixels": "Allen Neuropixels",
     "speech": "Attempted speech",
-    "mc_pacman": "MC PacMan force decoding",
-    "ratinabox": "RatInABox navigation",
+    "mc_pacman": "MC PacMan",
+    "ratinabox": "RatInABox",
 }
 
 DATASET_TICK_LABELS = {
     "monkey": "Macaque<br>center-out reaching",
-    "allen_neuropixels": "Allen<br>visual coding",
+    "allen_neuropixels": "Allen<br>Neuropixels",
     "speech": "Attempted<br>speech",
-    "mc_pacman": "MC PacMan<br>force decoding",
-    "ratinabox": "RatInABox<br>navigation",
+    "mc_pacman": "MC<br>PacMan",
+    "ratinabox": "RatInABox",
 }
 
 DATASET_DESCRIPTIONS = {
@@ -113,6 +115,28 @@ CONSISTENCY_SCALE = [[0.0, "#F1FAF8"], [1.0, CONSISTENCY_COLOR]]
 FEATURE_SCALE = [[0.0, "#F7F2FA"], [1.0, FEATURE_COLOR]]
 TRIAL_SCALE = [[0.0, "#F8F2FA"], [1.0, TRIAL_COLOR]]
 
+ATTRIBUTION_BIN_ORDER = ["Top", "Middle", "Bottom"]
+ATTRIBUTION_BIN_COLORS = {
+    "Top": "#238B45",
+    "Middle": "#74C476",
+    "Bottom": "#D9F0A3",
+}
+FEATURE_GROUP_COLORS = {
+    "monkey": {"Recorded": "#0072B2", "Synthetic control": "#BDBDBD"},
+    "speech": {"Recorded": "#009E73", "Synthetic control": "#BDBDBD"},
+    "mc_pacman": {"Recorded": "#D55E00", "Synthetic control": "#BDBDBD"},
+    "allen_neuropixels": {
+        "High orientation selectivity": "#E69F00",
+        "Intermediate orientation selectivity": "#F0E442",
+        "Low orientation selectivity": "#BDBDBD",
+    },
+    "ratinabox": {
+        "Place": "#CC79A7",
+        "Head direction": "#56B4E9",
+        "Speed": "#E69F00",
+    },
+}
+
 MODEL_COLORS = {
     model: color
     for model, color in zip(
@@ -295,11 +319,15 @@ NUMERIC_COLUMNS = {
 }
 
 DOWNLOADABLE_FILES = {
+    "dataset_overview.csv",
+    "dataset_example_neural.csv",
+    "dataset_example_targets.csv",
     "clean_prediction_summary.csv",
     "robustness_summary.csv",
     "consistency_summary.csv",
     "scalability_summary.csv",
     "neuron_shap_summary.csv",
+    "neuron_attributions.csv",
     "trial_shapley_summary.csv",
     "trial_shapley_retrain_summary.csv",
     "trial_historical_trajectories.csv",
@@ -391,11 +419,15 @@ def load_historical_trajectories() -> pd.DataFrame:
     return frame.sort_values(["direction_index", "trial_index", "time_index"]).reset_index(drop=True)
 
 
+dataset_overview = load_csv("dataset_overview.csv")
+dataset_example_neural = load_csv("dataset_example_neural.csv")
+dataset_example_targets = load_csv("dataset_example_targets.csv")
 prediction = load_csv("clean_prediction_summary.csv")
 robustness = load_csv("robustness_summary.csv")
 consistency = load_csv("consistency_summary.csv")
 scalability = load_csv("scalability_summary.csv")
 neuron_shap = load_csv("neuron_shap_summary.csv")
+neuron_attributions = load_csv("neuron_attributions.csv")
 trial_shapley = load_csv("trial_shapley_summary.csv")
 trial_retrain = load_csv("trial_shapley_retrain_summary.csv")
 trial_historical_trajectories = load_historical_trajectories()
@@ -792,6 +824,226 @@ def overview_frame(dataset: str, models: Sequence[str] | None) -> pd.DataFrame:
     return round_numeric(frame)
 
 
+def dataset_cards(selected_dataset: str) -> list[html.Article]:
+    cards: list[html.Article] = []
+    ordered = dataset_overview.set_index("dataset").reindex(DATASETS).reset_index()
+    for row in ordered.itertuples(index=False):
+        classes = "dataset-card"
+        if str(row.dataset) == str(selected_dataset):
+            classes += " dataset-card-selected"
+        cards.append(
+            html.Article(
+                [
+                    html.Div(str(row.dataset_name), className="dataset-card-title"),
+                    html.Div(
+                        f"{row.species} · {row.task}",
+                        className="dataset-card-context",
+                    ),
+                    html.Div(
+                        [
+                            html.Div(
+                                [
+                                    html.Span(
+                                        "Primary array",
+                                        className="dataset-fact-label",
+                                        title="Trials × time bins × features",
+                                    ),
+                                    html.Strong(str(row.array_shape)),
+                                ]
+                            ),
+                            html.Div(
+                                [
+                                    html.Span("Target", className="dataset-fact-label"),
+                                    html.Strong(f"{row.target} · {row.score}"),
+                                ]
+                            ),
+                            html.Div(
+                                [
+                                    html.Span("Sampling", className="dataset-fact-label"),
+                                    html.Strong(f"{float(row.bin_ms):g} ms bins"),
+                                ]
+                            ),
+                            html.Div(
+                                [
+                                    html.Span("Consistency cohort", className="dataset-fact-label"),
+                                    html.Strong(str(row.recordings)),
+                                ]
+                            ),
+                        ],
+                        className="dataset-facts",
+                    ),
+                    html.A(
+                        str(row.source_label),
+                        href=str(row.source_url),
+                        target="_blank",
+                        rel="noopener noreferrer",
+                        className="dataset-source",
+                    ),
+                ],
+                className=classes,
+            )
+        )
+    return cards
+
+
+def dataset_example_figures(dataset: str) -> tuple[go.Figure, go.Figure, str]:
+    metadata = dataset_overview[dataset_overview["dataset"].astype(str).eq(dataset)].iloc[0]
+    neural = dataset_example_neural[
+        dataset_example_neural["dataset"].astype(str).eq(dataset)
+    ].copy()
+    target = dataset_example_targets[
+        dataset_example_targets["dataset"].astype(str).eq(dataset)
+    ].copy()
+    for column in (
+        "time_index",
+        "time_ms",
+        "feature_display_index",
+        "feature_index",
+        "neural_value",
+    ):
+        neural[column] = pd.to_numeric(neural[column], errors="coerce")
+
+    values = neural.pivot(
+        index="feature_display_index", columns="time_index", values="neural_value"
+    ).sort_index()
+    time_values = (
+        neural[["time_index", "time_ms"]]
+        .drop_duplicates()
+        .sort_values("time_index")["time_ms"]
+        .to_numpy(dtype=float)
+    )
+    feature_ids = (
+        neural[["feature_display_index", "feature_index"]]
+        .drop_duplicates()
+        .sort_values("feature_display_index")["feature_index"]
+        .to_numpy(dtype=int)
+    )
+    customdata = np.repeat(feature_ids[:, None], values.shape[1], axis=1)
+    upper = max(float(np.nanpercentile(values.to_numpy(dtype=float), 99.5)), 1.0)
+    neural_figure = go.Figure(
+        go.Heatmap(
+            z=values.to_numpy(dtype=float),
+            x=time_values,
+            y=np.arange(len(feature_ids)),
+            customdata=customdata,
+            colorscale=[[0.0, "#F7FAFC"], [1.0, "#164E63"]],
+            zmin=0,
+            zmax=upper,
+            colorbar=dict(title="Count", thickness=13),
+            hovertemplate=(
+                "Feature=%{customdata}<br>Time=%{x:.0f} ms<br>"
+                "Neural value=%{z:.3f}<extra></extra>"
+            ),
+        )
+    )
+    neural_figure.add_vline(x=0, line_color="#D55E00", line_dash="dash")
+    neural_figure.update_layout(title="Neural activity")
+    neural_figure.update_xaxes(title="Time from scoring onset (ms)")
+    neural_figure.update_yaxes(title="Neural features", showticklabels=False)
+    figure_layout(neural_figure, height=470)
+
+    if dataset in {"allen_neuropixels", "speech"}:
+        label = str(target["target_label"].iloc[0])
+        target_figure = go.Figure()
+        if dataset == "allen_neuropixels":
+            angle = np.deg2rad(float(label.split("°")[0]))
+            x = np.asarray([-np.cos(angle), np.cos(angle)])
+            y = np.asarray([-np.sin(angle), np.sin(angle)])
+            target_figure.add_trace(
+                go.Scatter(
+                    x=x,
+                    y=y,
+                    mode="lines",
+                    line=dict(color="#E69F00", width=12),
+                    hoverinfo="skip",
+                )
+            )
+            target_figure.update_xaxes(visible=False, range=[-1.25, 1.25])
+            target_figure.update_yaxes(
+                visible=False,
+                range=[-1.25, 1.25],
+                scaleanchor="x",
+                scaleratio=1,
+            )
+            target_figure.add_annotation(
+                text=label,
+                x=0.5,
+                y=0.08,
+                xref="paper",
+                yref="paper",
+                showarrow=False,
+                font=dict(size=18),
+            )
+            target_figure.update_layout(title="Target orientation")
+        else:
+            target_figure.add_annotation(
+                text=label,
+                x=0.5,
+                y=0.52,
+                xref="paper",
+                yref="paper",
+                showarrow=False,
+                font=dict(size=36, color=FEATURE_COLOR),
+            )
+            target_figure.update_xaxes(visible=False)
+            target_figure.update_yaxes(visible=False)
+            target_figure.update_layout(title="Attempted-word target")
+        figure_layout(target_figure, height=470)
+    else:
+        for column in ("time_ms", "target_0", "target_1"):
+            target[column] = pd.to_numeric(target[column], errors="coerce")
+        if dataset == "mc_pacman":
+            target_figure = go.Figure(
+                go.Scatter(
+                    x=target["time_ms"],
+                    y=target["target_0"],
+                    mode="lines",
+                    line=dict(color="#D55E00", width=3),
+                    hovertemplate="Time=%{x:.0f} ms<br>Force=%{y:.4f}<extra></extra>",
+                )
+            )
+            target_figure.add_vline(x=0, line_color="#71808D", line_dash="dash")
+            target_figure.update_layout(title="Target force")
+            target_figure.update_xaxes(title="Time from scoring onset (ms)")
+            target_figure.update_yaxes(title="Force")
+        else:
+            target_figure = go.Figure(
+                go.Scatter(
+                    x=target["target_0"],
+                    y=target["target_1"],
+                    mode="lines+markers",
+                    line=dict(color=PREDICTION_COLOR, width=3),
+                    marker=dict(
+                        size=5,
+                        color=target["time_ms"],
+                        colorscale="Viridis",
+                        showscale=True,
+                        colorbar=dict(title="Time (ms)", thickness=13),
+                    ),
+                    customdata=target["time_ms"],
+                    hovertemplate=(
+                        "x=%{x:.3f}<br>y=%{y:.3f}<br>"
+                        "Time=%{customdata:.0f} ms<extra></extra>"
+                    ),
+                )
+            )
+            title = "Target hand position" if dataset == "monkey" else "Target position"
+            target_figure.update_layout(title=title)
+            target_figure.update_xaxes(title="x", scaleanchor="y", scaleratio=1)
+            target_figure.update_yaxes(title="y")
+        figure_layout(target_figure, height=470)
+
+    shown = int(metadata.example_features_shown)
+    total = int(metadata.array_shape.split("×")[-1].strip())
+    feature_text = (
+        f"all {total} neural features are shown"
+        if shown == total
+        else f"{shown} of {total} neural features are shown for legibility"
+    )
+    description = f"One example trial; {feature_text}."
+    return neural_figure, target_figure, description
+
+
 def overview_cards(dataset: str, models: Sequence[str] | None) -> list[html.Div]:
     frame = overview_frame(dataset, models)
     available = frame.dropna(subset=["task_score"]).sort_values(
@@ -1151,7 +1403,7 @@ def feature_spec(dataset: str) -> tuple[str, str, str, float | None]:
         return (
             "spearman_corr",
             "Drifting-gratings orientation selectivity",
-            "Spearman’s ρ",
+            "Spearman’s r",
             0.0,
         )
     if dataset == "ratinabox":
@@ -1253,6 +1505,180 @@ def feature_heatmap(models: Sequence[str] | None) -> go.Figure:
     )
 
 
+def feature_attribution_frame(dataset: str, model: str | None) -> pd.DataFrame:
+    if not model:
+        return pd.DataFrame(columns=neuron_attributions.columns)
+    frame = neuron_attributions[
+        neuron_attributions["dataset"].astype(str).eq(str(dataset))
+        & neuron_attributions["model"].astype(str).eq(str(model))
+    ].copy()
+    for column in (
+        "feature_index",
+        "signed_attribution",
+        "attribution_rank",
+        "validation_value",
+    ):
+        frame[column] = pd.to_numeric(frame[column], errors="coerce")
+    return frame.sort_values("attribution_rank", kind="stable")
+
+
+def rgba(hex_color: str, alpha: float) -> str:
+    value = hex_color.lstrip("#")
+    red, green, blue = (int(value[index : index + 2], 16) for index in (0, 2, 4))
+    return f"rgba({red},{green},{blue},{alpha})"
+
+
+def feature_attribution_figures(
+    dataset: str,
+    model: str | None,
+    selected_rank: int | None = None,
+) -> tuple[go.Figure, go.Figure, str]:
+    frame = feature_attribution_frame(dataset, model)
+    if frame.empty:
+        message = "Select an available method to inspect feature-level attributions."
+        return empty_figure(message, height=460), empty_figure(message, height=460), ""
+    if frame["signed_attribution"].nunique(dropna=True) <= 1:
+        message = "Signed feature-attribution values are tied for this method and dataset."
+        return empty_figure(message, height=480), empty_figure(message, height=480), message
+
+    rank_values = frame["attribution_rank"].astype(int)
+    if selected_rank is None or int(selected_rank) not in set(rank_values):
+        selected_rank = int(rank_values.min())
+    selected = frame[rank_values.eq(int(selected_rank))].iloc[0]
+    selected_group = str(selected["feature_group"])
+    selected_bin = str(selected["attribution_bin"])
+
+    group_colors = FEATURE_GROUP_COLORS[dataset]
+    rank_figure = go.Figure()
+    for group, color in group_colors.items():
+        subset = frame[frame["feature_group"].astype(str).eq(group)]
+        if subset.empty:
+            continue
+        customdata = np.stack(
+            [subset["feature_index"], subset["attribution_rank"], subset["validation_value"]],
+            axis=-1,
+        )
+        validation_hover = (
+            "<br>Orientation selectivity=%{customdata[2]:.4f}"
+            if dataset == "allen_neuropixels"
+            else ""
+        )
+        rank_figure.add_trace(
+            go.Scatter(
+                x=subset["attribution_rank"],
+                y=subset["signed_attribution"],
+                mode="markers",
+                name=group,
+                marker=dict(
+                    color=color,
+                    size=5 if len(frame) > 300 else 7,
+                    opacity=0.78,
+                    line=dict(color="#FFFFFF", width=0.4),
+                ),
+                customdata=customdata,
+                hovertemplate=(
+                    "Feature=%{customdata[0]:.0f}<br>Group="
+                    + group
+                    + "<br>Rank=%{customdata[1]:.0f}<br>Signed attribution=%{y:.5f}"
+                    + validation_hover
+                    + "<extra></extra>"
+                ),
+            )
+        )
+    rank_figure.add_trace(
+        go.Scatter(
+            x=[int(selected["attribution_rank"])],
+            y=[float(selected["signed_attribution"])],
+            mode="markers",
+            name="Selected feature",
+            showlegend=False,
+            marker=dict(
+                color=group_colors[selected_group],
+                size=14,
+                line=dict(color="#172938", width=2.2),
+            ),
+            hovertemplate=(
+                f"Feature index={int(selected['feature_index'])}<br>"
+                f"Group={selected_group}<br>Rank={int(selected['attribution_rank'])}<br>"
+                f"Signed attribution={float(selected['signed_attribution']):.5f}"
+                "<extra></extra>"
+            ),
+        )
+    )
+    rank_figure.add_hline(y=0, line_color="#71808D", line_dash="dash")
+    rank_figure.update_layout(title="Signed feature ranking")
+    rank_figure.update_xaxes(title="Attribution rank")
+    rank_figure.update_yaxes(title="Signed Kernel SHAP value")
+    figure_layout(rank_figure, height=480, legend_below=True)
+
+    groups = [group for group in group_colors if group in set(frame["feature_group"])]
+    nodes = groups + ATTRIBUTION_BIN_ORDER
+    node_index = {label: index for index, label in enumerate(nodes)}
+    counts = (
+        frame.groupby(["feature_group", "attribution_bin"], observed=True)
+        .size()
+        .to_dict()
+    )
+    sources: list[int] = []
+    targets: list[int] = []
+    values: list[int] = []
+    link_colors: list[str] = []
+    for group in groups:
+        for rank_bin in ATTRIBUTION_BIN_ORDER:
+            count = int(counts.get((group, rank_bin), 0))
+            if count == 0:
+                continue
+            sources.append(node_index[group])
+            targets.append(node_index[rank_bin])
+            values.append(count)
+            is_selected_route = group == selected_group and rank_bin == selected_bin
+            link_colors.append(
+                rgba(group_colors[group], 0.78 if is_selected_route else 0.18)
+            )
+
+    source_y = np.linspace(0.08, 0.92, len(groups)).tolist()
+    target_y = [0.12, 0.5, 0.88]
+    sankey = go.Figure(
+        go.Sankey(
+            arrangement="fixed",
+            node=dict(
+                label=groups + [f"{label} third" for label in ATTRIBUTION_BIN_ORDER],
+                color=[group_colors[group] for group in groups]
+                + [ATTRIBUTION_BIN_COLORS[label] for label in ATTRIBUTION_BIN_ORDER],
+                line=dict(color="#FFFFFF", width=0.8),
+                pad=18,
+                thickness=18,
+                x=[0.02] * len(groups) + [0.98] * len(ATTRIBUTION_BIN_ORDER),
+                y=source_y + target_y,
+                hovertemplate="%{label}<br>%{value:.0f} features<extra></extra>",
+            ),
+            link=dict(
+                source=sources,
+                target=targets,
+                value=values,
+                color=link_colors,
+                hovertemplate=(
+                    "%{source.label} → %{target.label}<br>"
+                    "%{value:.0f} features<extra></extra>"
+                ),
+            ),
+        )
+    )
+    sankey.update_layout(title="Feature groups by attribution rank")
+    figure_layout(sankey, height=480)
+    sankey.update_layout(margin=dict(l=28, r=28, t=62, b=30))
+
+    detail = (
+        f"Feature index {int(selected['feature_index'])} · "
+        f"rank {int(selected['attribution_rank'])} of {len(frame)} · "
+        f"{selected_group} → {selected_bin.lower()} third · "
+        f"signed Kernel SHAP {float(selected['signed_attribution']):+.5f}"
+    )
+    if dataset == "allen_neuropixels" and pd.notna(selected["validation_value"]):
+        detail += f" · orientation selectivity {float(selected['validation_value']):.4f}"
+    return rank_figure, sankey, detail
+
+
 def trial_frame(dataset: str, models: Sequence[str] | None) -> pd.DataFrame:
     frame = filter_models(active_rows(trial_shapley), models)
     frame = frame[frame["dataset"].astype(str) == str(dataset)].copy()
@@ -2126,6 +2552,47 @@ app.layout = html.Div(
                 value="overview",
                 className="tabs",
                 children=[
+                dcc.Tab(
+                    label="Datasets",
+                    value="datasets",
+                    className="tab",
+                    selected_className="tab tab-selected",
+                    children=[
+                        panel(
+                            "Benchmark datasets",
+                            html.Div(id="dataset-cards", className="dataset-card-grid"),
+                            subtitle="Motor, visual, speech and spatial decoding across recordings, participants and simulations. Array dimensions are trials × time bins × features.",
+                            class_name="axis-datasets",
+                        ),
+                        panel(
+                            "Example benchmark input and target",
+                            html.Div(
+                                [
+                                    graph_box(
+                                        "dataset-neural-example",
+                                        "Example trial neural activity for the selected dataset.",
+                                    ),
+                                    graph_box(
+                                        "dataset-target-example",
+                                        "Paired task target for the selected example trial.",
+                                    ),
+                                ],
+                                className="chart-grid two",
+                            ),
+                            html.Div(id="dataset-example-description", className="dataset-example-note"),
+                            html.Div(
+                                [
+                                    source_link("dataset_overview.csv", "Dataset manifest"),
+                                    source_link("dataset_example_neural.csv", "Example neural data"),
+                                    source_link("dataset_example_targets.csv", "Example targets"),
+                                ],
+                                className="download-grid panel-downloads",
+                            ),
+                            subtitle="Examples are drawn from the preprocessed arrays used in the benchmark.",
+                            class_name="axis-datasets",
+                        ),
+                    ],
+                ),
                 dcc.Tab(
                     label="Overview",
                     value="overview",
@@ -2228,6 +2695,54 @@ app.layout = html.Div(
                     className="tab",
                     selected_className="tab tab-selected",
                     children=[
+                        panel(
+                            "Feature-level attribution",
+                            html.Div(
+                                [
+                                    html.Div(
+                                        [
+                                            html.Label("Method", htmlFor="feature-method"),
+                                            dcc.Dropdown(id="feature-method", clearable=False),
+                                        ],
+                                        className="control",
+                                    ),
+                                    html.Div(
+                                        [
+                                            html.Label("Feature rank", htmlFor="feature-rank"),
+                                            dcc.Slider(
+                                                id="feature-rank",
+                                                min=1,
+                                                max=2,
+                                                step=1,
+                                                value=1,
+                                                marks={1: "Highest", 2: "Lowest"},
+                                                disabled=True,
+                                                tooltip={"placement": "bottom"},
+                                            ),
+                                        ],
+                                        className="control feature-rank-control",
+                                    ),
+                                ],
+                                className="inline-controls feature-controls",
+                            ),
+                            html.Div(id="feature-selection-detail", className="feature-selection-detail"),
+                            html.Div(
+                                [
+                                    graph_box(
+                                        "feature-rank-plot",
+                                        "Signed neural-feature attributions ranked from highest to lowest.",
+                                    ),
+                                    graph_box(
+                                        "feature-sankey",
+                                        "Feature groups mapped to top, middle and bottom attribution-rank thirds.",
+                                    ),
+                                ],
+                                className="chart-grid two",
+                            ),
+                            source_link("neuron_attributions.csv", "Feature-level CSV"),
+                            subtitle="Move through the signed Kernel SHAP ranking to highlight where each input feature falls. Ranks are within the selected method and dataset.",
+                            class_name="axis-feature",
+                        ),
                         panel(
                             "Feature-attribution validation",
                             html.Div(
@@ -2331,6 +2846,19 @@ app.layout = html.Div(
 )
 
 
+@app.callback(
+    Output("dataset-cards", "children"),
+    Output("dataset-neural-example", "figure"),
+    Output("dataset-target-example", "figure"),
+    Output("dataset-example-description", "children"),
+    Input("dataset-filter", "value"),
+)
+def update_dataset_examples(dataset: str):
+    dataset = dataset or DATASETS[0]
+    neural, target, description = dataset_example_figures(dataset)
+    return dataset_cards(dataset), neural, target, description
+
+
 @app.callback(
     Output("overview-cards", "children"),
     Output("overview-table", "columns"),
@@ -2468,6 +2996,82 @@ def update_consistency(
     )
 
 
+@app.callback(
+    Output("feature-method", "options"),
+    Output("feature-method", "value"),
+    Output("feature-method", "disabled"),
+    Input("dataset-filter", "value"),
+    Input("method-filter", "value"),
+    State("feature-method", "value"),
+)
+def update_feature_selector(
+    dataset: str,
+    models: list[str] | None,
+    current: str | None,
+):
+    dataset = dataset or DATASETS[0]
+    frame = feature_frame(dataset, models).dropna(subset=["validation_score"])
+    available_pairs = set(
+        zip(
+            neuron_attributions["model"].astype(str),
+            neuron_attributions["dataset"].astype(str),
+        )
+    )
+    available = [
+        model
+        for model in frame.sort_values(
+            ["validation_score", "model_order"], ascending=[False, True]
+        )["model"].astype(str)
+        if (model, dataset) in available_pairs
+    ]
+    options = [
+        {"label": dataset_model_label(model, dataset), "value": model}
+        for model in available
+    ]
+    value = current if current in available else (available[0] if available else None)
+    return options, value, not bool(options)
+
+
+@app.callback(
+    Output("feature-rank", "max"),
+    Output("feature-rank", "value"),
+    Output("feature-rank", "marks"),
+    Output("feature-rank", "disabled"),
+    Input("dataset-filter", "value"),
+    Input("feature-method", "value"),
+    State("feature-rank", "value"),
+)
+def update_feature_rank_slider(
+    dataset: str,
+    method: str | None,
+    current_rank: int | None,
+):
+    frame = feature_attribution_frame(dataset or DATASETS[0], method)
+    if frame.empty or frame["signed_attribution"].nunique(dropna=True) <= 1:
+        return 2, 1, {1: "Highest", 2: "Lowest"}, True
+    maximum = int(frame["attribution_rank"].max())
+    value = int(current_rank) if current_rank and int(current_rank) <= maximum else 1
+    return maximum, value, {1: "Highest", maximum: "Lowest"}, False
+
+
+@app.callback(
+    Output("feature-rank-plot", "figure"),
+    Output("feature-sankey", "figure"),
+    Output("feature-selection-detail", "children"),
+    Input("dataset-filter", "value"),
+    Input("feature-method", "value"),
+    Input("feature-rank", "value"),
+)
+def update_feature_attributions(
+    dataset: str,
+    method: str | None,
+    selected_rank: int | None,
+):
+    return feature_attribution_figures(
+        dataset or DATASETS[0], method, selected_rank
+    )
+
+
 @app.callback(
     Output("feature-definition", "children"),
     Output("feature-validation-bars", "figure"),
@@ -2483,7 +3087,7 @@ def update_feature(dataset: str, models: list[str] | None):
     _column, _target, metric, _reference = feature_spec(dataset)
     if dataset == "allen_neuropixels":
         definition = (
-            "Spearman’s ρ measures association between feature-attribution values "
+            "Spearman’s r measures association between feature-attribution values "
             "and each unit’s drifting-gratings orientation selectivity."
         )
     elif dataset == "ratinabox":

assets/styles.css

@@ -6,6 +6,7 @@
   --paper: #ffffff;
   --canvas: #f7f8f9;
   --prediction: #1565c0;
+  --datasets: #455a64;
   --robustness: #2e7d32;
   --compute: #e65100;
   --consistency: #007c91;
@@ -156,8 +157,8 @@ h1 {
   border: 1px solid #d5dde3;
   border-radius: 999px;
   background: #ffffff;
-  color: #71808b;
-  font-size: 9px;
+  color: #5f707d;
+  font-size: 10px;
   font-weight: 750;
   letter-spacing: 0.035em;
   line-height: 1.4;
@@ -282,6 +283,10 @@ h1 {
   border-top-color: var(--prediction);
 }
 
+.panel.axis-datasets {
+  border-top-color: var(--datasets);
+}
+
 .panel.axis-robustness {
   border-top-color: var(--robustness);
 }
@@ -320,6 +325,10 @@ h1 {
   color: var(--prediction);
 }
 
+.axis-datasets .section-eyebrow {
+  color: var(--datasets);
+}
+
 .axis-robustness .section-eyebrow {
   color: var(--robustness);
 }
@@ -363,6 +372,105 @@ h2 {
   margin-bottom: 14px;
 }
 
+.dataset-card-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+  gap: 12px;
+}
+
+.dataset-card {
+  position: relative;
+  overflow: hidden;
+  padding: 17px 16px 15px;
+  border: 1px solid #dce4e9;
+  border-radius: 9px;
+  background: #ffffff;
+}
+
+.dataset-card::before {
+  position: absolute;
+  top: 0;
+  right: 0;
+  left: 0;
+  height: 3px;
+  background: #aeb9c1;
+  content: "";
+}
+
+.dataset-card-selected {
+  border-color: #98aab6;
+  box-shadow: 0 4px 14px rgba(39, 58, 72, 0.08);
+}
+
+.dataset-card-selected::before {
+  background: var(--datasets);
+}
+
+.dataset-card-title {
+  color: #172938;
+  font-size: 15px;
+  font-weight: 780;
+  line-height: 1.25;
+}
+
+.dataset-card-context {
+  min-height: 36px;
+  margin-top: 5px;
+  color: #657684;
+  font-size: 11px;
+  line-height: 1.45;
+}
+
+.dataset-facts {
+  display: grid;
+  gap: 7px;
+  margin-top: 12px;
+  padding-top: 11px;
+  border-top: 1px solid var(--soft-line);
+}
+
+.dataset-facts > div {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.dataset-fact-label {
+  color: #758590;
+  font-size: 10px;
+  font-weight: 800;
+  letter-spacing: 0.055em;
+  text-transform: uppercase;
+}
+
+.dataset-facts strong {
+  color: #324654;
+  font-size: 11px;
+  font-weight: 700;
+  text-align: right;
+}
+
+.dataset-source {
+  display: inline-block;
+  margin-top: 12px;
+  color: #355b77;
+  font-size: 11px;
+  font-weight: 750;
+  text-decoration: none;
+}
+
+.dataset-source::after {
+  margin-left: 4px;
+  content: "↗";
+}
+
+.dataset-example-note {
+  margin-top: 12px;
+  color: #637581;
+  font-size: 11px;
+}
+
 .metric-card {
   position: relative;
   min-width: 0;
@@ -511,6 +619,30 @@ h2 {
   background: #fafbfc;
 }
 
+.inline-controls.single {
+  grid-template-columns: minmax(240px, 420px);
+}
+
+.feature-controls {
+  grid-template-columns: minmax(240px, 360px) minmax(320px, 1fr);
+}
+
+.feature-rank-control {
+  padding: 0 7px 7px;
+}
+
+.feature-selection-detail {
+  min-height: 36px;
+  margin: 0 0 12px;
+  padding: 9px 11px;
+  border-left: 3px solid var(--feature);
+  border-radius: 6px;
+  background: #f8f6fb;
+  color: #445664;
+  font-size: 12px;
+  line-height: 1.45;
+}
+
 .details-table {
   margin-top: 15px;
   border: 1px solid #e1e7eb;
@@ -711,10 +843,6 @@ h2 {
     gap: 14px;
   }
 
-  .nav-placeholder small {
-    display: none;
-  }
-
   .toolbar {
     position: relative;
     grid-template-columns: 1fr;
@@ -739,6 +867,10 @@ h2 {
     grid-template-columns: 1fr;
   }
 
+  .modebar-container {
+    display: none !important;
+  }
+
   .heatmap-graph,
   .latent-graph {
     overflow-x: auto;

data/dataset_example_targets.csv

@@ -0,0 +1,215 @@
+dataset,trial_index,time_index,time_ms,target_0,target_1,target_label
+monkey,19,0,-300.0,0.32637837529182434,0.9757941961288452,
+monkey,19,1,-280.0,0.3266376554965973,0.9760781526565552,
+monkey,19,2,-260.0,0.32639679312705994,0.9759191870689392,
+monkey,19,3,-240.0,0.3267260789871216,0.9760299921035767,
+monkey,19,4,-220.0,0.32616183161735535,0.9759241938591003,
+monkey,19,5,-200.0,0.3303698003292084,0.9805266261100769,
+monkey,19,6,-180.0,0.3312961757183075,0.9897047281265259,
+monkey,19,7,-160.0,0.33124345541000366,0.9998650550842285,
+monkey,19,8,-140.0,0.3350425660610199,1.0021278858184814,
+monkey,19,9,-120.0,0.33221206068992615,1.003627061843872,
+monkey,19,10,-100.0,0.3279237151145935,1.0078579187393188,
+monkey,19,11,-80.0,0.32607147097587585,1.0092488527297974,
+monkey,19,12,-60.0,0.3212782144546509,1.0135948657989502,
+monkey,19,13,-40.0,0.31931623816490173,1.015254259109497,
+monkey,19,14,-20.0,0.31412604451179504,1.0198619365692139,
+monkey,19,15,0.0,0.314896821975708,1.0191636085510254,
+monkey,19,16,20.0,0.3141116797924042,1.019865870475769,
+monkey,19,17,40.0,0.3087146580219269,1.0246158838272095,
+monkey,19,18,60.0,0.3078997731208801,1.0253390073776245,
+monkey,19,19,80.0,0.3083854913711548,1.0249062776565552,
+monkey,19,20,100.0,0.30375054478645325,1.0289989709854126,
+monkey,19,21,120.0,0.2999488115310669,1.0323445796966553,
+monkey,19,22,140.0,0.2953139543533325,1.0364488363265991,
+monkey,19,23,160.0,0.29061010479927063,1.040581226348877,
+monkey,19,24,180.0,0.2853701710700989,1.045244812965393,
+monkey,19,25,200.0,0.27945226430892944,1.0504240989685059,
+monkey,19,26,220.0,0.27346527576446533,1.0558046102523804,
+monkey,19,27,240.0,0.26590073108673096,1.062351942062378,
+monkey,19,28,260.0,0.2580970227718353,1.069669246673584,
+monkey,19,29,280.0,0.252856969833374,1.0822207927703857,
+monkey,19,30,300.0,0.24749480187892914,1.0943732261657715,
+monkey,19,31,320.0,0.2417447715997696,1.1059606075286865,
+monkey,19,32,340.0,0.2357359230518341,1.1191096305847168,
+monkey,19,33,360.0,0.2288716584444046,1.1295506954193115,
+monkey,19,34,380.0,0.22376346588134766,1.1424471139907837,
+monkey,19,35,400.0,0.2146560549736023,1.152639389038086,
+monkey,19,36,420.0,0.20424097776412964,1.1610658168792725,
+monkey,19,37,440.0,0.19646596908569336,1.1687617301940918,
+monkey,19,38,460.0,0.1878175586462021,1.1754132509231567,
+monkey,19,39,480.0,0.1806408017873764,1.187225580215454,
+monkey,19,40,500.0,0.177394300699234,1.2083221673965454,
+monkey,19,41,520.0,0.17321859300136566,1.2519882917404175,
+monkey,19,42,540.0,0.16704171895980835,1.3540817499160767,
+monkey,19,43,560.0,0.15717653930187225,1.5343878269195557,
+monkey,19,44,580.0,0.1392321139574051,1.7867273092269897,
+monkey,19,45,600.0,0.11189127713441849,2.11149001121521,
+monkey,19,46,620.0,0.09077581763267517,2.504103422164917,
+monkey,19,47,640.0,0.08320548385381699,2.9608612060546875,
+monkey,19,48,660.0,0.0900033712387085,3.4947991371154785,
+monkey,19,49,680.0,0.09981474280357361,4.108597755432129,
+allen_neuropixels,0,100,0.0,,,315° orientation
+speech,0,25,0.0,,,choice
+mc_pacman,0,0,-500.0,0.4540364742279053,,
+mc_pacman,0,1,-480.0,0.47354891896247864,,
+mc_pacman,0,2,-460.0,0.49371257424354553,,
+mc_pacman,0,3,-440.0,0.5081393122673035,,
+mc_pacman,0,4,-420.0,0.5131196975708008,,
+mc_pacman,0,5,-400.0,0.5209791660308838,,
+mc_pacman,0,6,-380.0,0.5383294820785522,,
+mc_pacman,0,7,-360.0,0.5535526275634766,,
+mc_pacman,0,8,-340.0,0.5599618554115295,,
+mc_pacman,0,9,-320.0,0.5621652007102966,,
+mc_pacman,0,10,-300.0,0.5593769550323486,,
+mc_pacman,0,11,-280.0,0.5489000678062439,,
+mc_pacman,0,12,-260.0,0.535784900188446,,
+mc_pacman,0,13,-240.0,0.5225427150726318,,
+mc_pacman,0,14,-220.0,0.5026987195014954,,
+mc_pacman,0,15,-200.0,0.4764695167541504,,
+mc_pacman,0,16,-180.0,0.46249258518218994,,
+mc_pacman,0,17,-160.0,0.4804723858833313,,
+mc_pacman,0,18,-140.0,0.5240657329559326,,
+mc_pacman,0,19,-120.0,0.5628992319107056,,
+mc_pacman,0,20,-100.0,0.570605993270874,,
+mc_pacman,0,21,-80.0,0.5441458225250244,,
+mc_pacman,0,22,-60.0,0.5028995871543884,,
+mc_pacman,0,23,-40.0,0.47658416628837585,,
+mc_pacman,0,24,-20.0,0.4860197901725769,,
+mc_pacman,0,25,0.0,0.5244206190109253,,
+mc_pacman,0,26,20.0,0.5643056035041809,,
+mc_pacman,0,27,40.0,0.588422417640686,,
+mc_pacman,0,28,60.0,0.5981853008270264,,
+mc_pacman,0,29,80.0,0.5974154472351074,,
+mc_pacman,0,30,100.0,0.592046320438385,,
+mc_pacman,0,31,120.0,0.5933641791343689,,
+mc_pacman,0,32,140.0,0.601443350315094,,
+mc_pacman,0,33,160.0,0.606227457523346,,
+mc_pacman,0,34,180.0,0.6097249388694763,,
+mc_pacman,0,35,200.0,0.6227228045463562,,
+mc_pacman,0,36,220.0,0.6448730826377869,,
+mc_pacman,0,37,240.0,0.6626847982406616,,
+mc_pacman,0,38,260.0,0.6634147763252258,,
+mc_pacman,0,39,280.0,0.6510913372039795,,
+mc_pacman,0,40,300.0,0.6460963487625122,,
+mc_pacman,0,41,320.0,0.6580253839492798,,
+mc_pacman,0,42,340.0,0.6721721887588501,,
+mc_pacman,0,43,360.0,0.6763845682144165,,
+mc_pacman,0,44,380.0,0.6803927421569824,,
+mc_pacman,0,45,400.0,0.6943899393081665,,
+mc_pacman,0,46,420.0,0.705275297164917,,
+mc_pacman,0,47,440.0,0.691665768623352,,
+mc_pacman,0,48,460.0,0.6565446853637695,,
+mc_pacman,0,49,480.0,0.6260090470314026,,
+mc_pacman,0,50,500.0,0.61765056848526,,
+mc_pacman,0,51,520.0,0.62873774766922,,
+mc_pacman,0,52,540.0,0.653647243976593,,
+mc_pacman,0,53,560.0,0.6875089406967163,,
+mc_pacman,0,54,580.0,0.7174137234687805,,
+mc_pacman,0,55,600.0,0.7349939942359924,,
+mc_pacman,0,56,620.0,0.7430776357650757,,
+mc_pacman,0,57,640.0,0.7382182478904724,,
+mc_pacman,0,58,660.0,0.7191638946533203,,
+mc_pacman,0,59,680.0,0.7111793160438538,,
+mc_pacman,0,60,700.0,0.7467876076698303,,
+mc_pacman,0,61,720.0,0.8286340832710266,,
+mc_pacman,0,62,740.0,0.9286566376686096,,
+mc_pacman,0,63,760.0,1.0168689489364624,,
+mc_pacman,0,64,780.0,1.0888168811798096,,
+mc_pacman,0,65,800.0,1.1605585813522339,,
+mc_pacman,0,66,820.0,1.2344834804534912,,
+mc_pacman,0,67,840.0,1.292007327079773,,
+mc_pacman,0,68,860.0,1.329041838645935,,
+mc_pacman,0,69,880.0,1.3740489482879639,,
+mc_pacman,0,70,900.0,1.4568270444869995,,
+mc_pacman,0,71,920.0,1.5872440338134766,,
+mc_pacman,0,72,940.0,1.7747671604156494,,
+mc_pacman,0,73,960.0,2.02529239654541,,
+mc_pacman,0,74,980.0,2.306344509124756,,
+mc_pacman,0,75,1000.0,2.5660526752471924,,
+mc_pacman,0,76,1020.0,2.7944984436035156,,
+mc_pacman,0,77,1040.0,3.01857328414917,,
+mc_pacman,0,78,1060.0,3.2419419288635254,,
+mc_pacman,0,79,1080.0,3.4372360706329346,,
+mc_pacman,0,80,1100.0,3.5911450386047363,,
+mc_pacman,0,81,1120.0,3.7210190296173096,,
+mc_pacman,0,82,1140.0,3.8501505851745605,,
+mc_pacman,0,83,1160.0,3.9841997623443604,,
+mc_pacman,0,84,1180.0,4.111367225646973,,
+mc_pacman,0,85,1200.0,4.223678112030029,,
+mc_pacman,0,86,1220.0,4.3313422203063965,,
+mc_pacman,0,87,1240.0,4.443793296813965,,
+mc_pacman,0,88,1260.0,4.5481343269348145,,
+mc_pacman,0,89,1280.0,4.624568939208984,,
+mc_pacman,0,90,1300.0,4.674068450927734,,
+mc_pacman,0,91,1320.0,4.7209272384643555,,
+mc_pacman,0,92,1340.0,4.778489112854004,,
+mc_pacman,0,93,1360.0,4.846485137939453,,
+mc_pacman,0,94,1380.0,4.9120378494262695,,
+mc_pacman,0,95,1400.0,4.962754249572754,,
+mc_pacman,0,96,1420.0,5.003695964813232,,
+mc_pacman,0,97,1440.0,5.054315567016602,,
+mc_pacman,0,98,1460.0,5.122193813323975,,
+mc_pacman,0,99,1480.0,5.1932783126831055,,
+mc_pacman,0,100,1500.0,5.255855083465576,,
+mc_pacman,0,101,1520.0,5.3188982009887695,,
+mc_pacman,0,102,1540.0,5.396027565002441,,
+mc_pacman,0,103,1560.0,5.482247352600098,,
+mc_pacman,0,104,1580.0,5.557141304016113,,
+mc_pacman,0,105,1600.0,5.605292797088623,,
+mc_pacman,0,106,1620.0,5.631208896636963,,
+mc_pacman,0,107,1640.0,5.653810501098633,,
+mc_pacman,0,108,1660.0,5.6811137199401855,,
+mc_pacman,0,109,1680.0,5.702667713165283,,
+mc_pacman,0,110,1700.0,5.715582370758057,,
+mc_pacman,0,111,1720.0,5.735340595245361,,
+ratinabox,0,0,0.0,0.37413349747657776,0.938173770904541,
+ratinabox,0,1,100.0,0.38142383098602295,0.923097550868988,
+ratinabox,0,2,200.0,0.39421314001083374,0.9171221852302551,
+ratinabox,0,3,300.0,0.40402141213417053,0.9103533029556274,
+ratinabox,0,4,400.0,0.41216611862182617,0.9079484939575195,
+ratinabox,0,5,500.0,0.425046443939209,0.9090948104858398,
+ratinabox,0,6,600.0,0.44039642810821533,0.9029134511947632,
+ratinabox,0,7,700.0,0.45487937331199646,0.8972962498664856,
+ratinabox,0,8,800.0,0.46796661615371704,0.8919219374656677,
+ratinabox,0,9,900.0,0.48204344511032104,0.8924508094787598,
+ratinabox,0,10,1000.0,0.4945521652698517,0.8901085257530212,
+ratinabox,0,11,1100.0,0.5004682540893555,0.884657084941864,
+ratinabox,0,12,1200.0,0.508205235004425,0.8746210932731628,
+ratinabox,0,13,1300.0,0.5115118026733398,0.862112283706665,
+ratinabox,0,14,1400.0,0.5177260637283325,0.8499125242233276,
+ratinabox,0,15,1500.0,0.5179038643836975,0.8336840867996216,
+ratinabox,0,16,1600.0,0.5195140242576599,0.8199301362037659,
+ratinabox,0,17,1700.0,0.5207089185714722,0.807529091835022,
+ratinabox,0,18,1800.0,0.5157619118690491,0.7915142774581909,
+ratinabox,0,19,1900.0,0.5180566906929016,0.7749912142753601,
+ratinabox,0,20,2000.0,0.5197643041610718,0.7607824802398682,
+ratinabox,0,21,2100.0,0.5209691524505615,0.7504138946533203,
+ratinabox,0,22,2200.0,0.5253504514694214,0.7415164709091187,
+ratinabox,0,23,2300.0,0.5286636352539062,0.7361718416213989,
+ratinabox,0,24,2400.0,0.5302071571350098,0.7298526763916016,
+ratinabox,0,25,2500.0,0.5307698249816895,0.7216604948043823,
+ratinabox,0,26,2600.0,0.5259577631950378,0.7130606770515442,
+ratinabox,0,27,2700.0,0.5202022790908813,0.7063953876495361,
+ratinabox,0,28,2800.0,0.5116539001464844,0.6951087713241577,
+ratinabox,0,29,2900.0,0.5097408890724182,0.6869532465934753,
+ratinabox,0,30,3000.0,0.5076330900192261,0.680025041103363,
+ratinabox,0,31,3100.0,0.5051463842391968,0.6751620769500732,
+ratinabox,0,32,3200.0,0.5011398792266846,0.6684351563453674,
+ratinabox,0,33,3300.0,0.4966591000556946,0.6637135744094849,
+ratinabox,0,34,3400.0,0.4893237054347992,0.6558409929275513,
+ratinabox,0,35,3500.0,0.4827667474746704,0.6477018594741821,
+ratinabox,0,36,3600.0,0.4740392565727234,0.6415613889694214,
+ratinabox,0,37,3700.0,0.46337786316871643,0.631086528301239,
+ratinabox,0,38,3800.0,0.4466787278652191,0.6238975524902344,
+ratinabox,0,39,3900.0,0.4327094554901123,0.6180192828178406,
+ratinabox,0,40,4000.0,0.41705596446990967,0.6094726324081421,
+ratinabox,0,41,4100.0,0.4069020450115204,0.6019271016120911,
+ratinabox,0,42,4200.0,0.3972027897834778,0.5955141186714172,
+ratinabox,0,43,4300.0,0.38659921288490295,0.5887935757637024,
+ratinabox,0,44,4400.0,0.37808313965797424,0.5859121680259705,
+ratinabox,0,45,4500.0,0.3705003559589386,0.5837921500205994,
+ratinabox,0,46,4600.0,0.36420997977256775,0.5776630640029907,
+ratinabox,0,47,4700.0,0.3610799014568329,0.5762715339660645,
+ratinabox,0,48,4800.0,0.3595122992992401,0.5739803910255432,
+ratinabox,0,49,4900.0,0.35728511214256287,0.5691278576850891,

data/dataset_overview.csv

@@ -0,0 +1,6 @@
+dataset,dataset_name,species,task,array_shape,target,score,bin_ms,recordings,source_label,source_url,example_trial_index,example_features_shown
+monkey,Macaque center-out reaching,Macaque,Center-out reaching,319 × 50 × 59,2D hand position,R²,20.0,4 recordings,DANDI 000688,https://doi.org/10.48324/dandi.000688/0.250122.1735,19,59
+allen_neuropixels,Allen Neuropixels,Mouse,Drifting-grating visual coding,598 × 300 × 444,Eight-way orientation class,Accuracy,10.0,3 recordings,Siegle et al. 2021,https://doi.org/10.1038/s41586-020-03171-x,0,80
+speech,Attempted speech,Human,Isolated-word attempted speech,168 × 50 × 64,Eight-class attempted-speech label,Accuracy,20.0,4 participants,Kunz et al. dataset,https://doi.org/10.5061/dryad.gf1vhhn1j,0,64
+mc_pacman,MC PacMan,Macaque,Force decoding,362 × 112 × 128,One-dimensional force,R²,20.0,1 recording,MINT study,https://doi.org/10.7554/eLife.89421,0,80
+ratinabox,RatInABox,Synthetic,2D position decoding,300 × 50 × 300,2D position,R²,100.0,4 generated sessions,RatInABox,https://doi.org/10.7554/eLife.85274,0,80

data/release_manifest.json

@@ -5,7 +5,7 @@
   ],
   "manuscript_working_version": "manuscript_v7",
   "schema_version": 1,
-  "source": "paper/results, active consistency embedding artifacts, and Figure 5 prediction sidecars",
+  "source": "paper/results, active consistency and feature-attribution artifacts, benchmark dataset arrays, and Figure 5 prediction sidecars",
   "source_git_revision": "80def770609a52f45a835c6b62500b04cdc2b548",
   "source_repository": "https://github.com/TangLab-UBC/behavior_benchmarking",
   "source_worktree_dirty": true,
@@ -18,6 +18,18 @@
       "rows": 54,
       "sha256": "7039c0d38c288576e39ea6a1147a41eb2d395559b1d9b1de1b14eac3b3801b7f"
     },
+    "dataset_example_neural.csv": {
+      "rows": 43110,
+      "sha256": "7b564705c55ddde7b91dacb56688cb1f740a3bb88cc8e5d59f12a9cf18b19f07"
+    },
+    "dataset_example_targets.csv": {
+      "rows": 214,
+      "sha256": "5201302ac40cf05b36b76cb950bb03c8dbb8c5a026fa4ca653b29415413a9f53"
+    },
+    "dataset_overview.csv": {
+      "rows": 5,
+      "sha256": "b5fc3f2db54c30d4a7c038e5df869c3f3f3a9e609b84cea72400942f94d7605e"
+    },
     "latent_samples.csv": {
       "rows": 31140,
       "sha256": "bb484c47b78bd7a7d0a2bfea94296e726aa80034f87368b32302aaba0c5aa622"
@@ -26,6 +38,10 @@
       "rows": 75040,
       "sha256": "d15a19b50d7dbc517b4bf5de60a550fda6870327e5e59fb4a5ec37f01921abf5"
     },
+    "neuron_attributions.csv": {
+      "rows": 21606,
+      "sha256": "b61262977aeb153f6afcb710ef0a4b9ba83ba676751a7227a05d0ca81ceba248"
+    },
     "neuron_shap_summary.csv": {
       "rows": 105,
       "sha256": "a36430bdd193040c48e2ab9fd48570d9c37b9ad58025d8a02d2c84293c768389"

validate_data.py

@@ -41,6 +41,19 @@ EXPECTED_COVERAGE = {
 }
 
 REQUIRED_COLUMNS = {
+    "dataset_overview.csv": {
+        "dataset", "dataset_name", "species", "task", "array_shape",
+        "target", "score", "bin_ms", "recordings", "source_label",
+        "source_url", "example_trial_index", "example_features_shown",
+    },
+    "dataset_example_neural.csv": {
+        "dataset", "trial_index", "time_index", "time_ms",
+        "feature_display_index", "feature_index", "neural_value",
+    },
+    "dataset_example_targets.csv": {
+        "dataset", "trial_index", "time_index", "time_ms", "target_0",
+        "target_1", "target_label",
+    },
     "clean_prediction_summary.csv": {
         "model", "dataset", "status", "metric", "score", "decoder",
     },
@@ -61,6 +74,11 @@ REQUIRED_COLUMNS = {
         "shap_mean_value", "shap_min_value", "shap_max_value",
         "shap_fraction_positive", "shap_fraction_negative",
     },
+    "neuron_attributions.csv": {
+        "model", "dataset", "feature_index", "feature_group",
+        "signed_attribution", "attribution_rank", "attribution_bin",
+        "validation_value",
+    },
     "trial_shapley_summary.csv": {
         "model", "dataset", "is_active_model", "analysis", "perturbation_auc",
         "rotation_angle_deg", "rotation_subspace_dim_spec",
@@ -93,11 +111,15 @@ REQUIRED_COLUMNS = {
 }
 
 UNIQUE_KEYS = {
+    "dataset_overview.csv": ["dataset"],
+    "dataset_example_neural.csv": ["dataset", "time_index", "feature_display_index"],
+    "dataset_example_targets.csv": ["dataset", "time_index"],
     "clean_prediction_summary.csv": ["model", "dataset"],
     "robustness_summary.csv": ["model", "dataset"],
     "scalability_summary.csv": ["model", "dataset"],
     "consistency_summary.csv": ["model", "dataset"],
     "neuron_shap_summary.csv": ["model", "dataset"],
+    "neuron_attributions.csv": ["model", "dataset", "feature_index"],
     "trial_shapley_summary.csv": ["model", "dataset"],
     "trial_shapley_retrain_summary.csv": ["analysis", "model", "condition"],
 }
@@ -311,6 +333,79 @@ def validate_local(data_dir: Path) -> dict[str, pd.DataFrame]:
             observed = set(frames[name]["dataset"].dropna().astype(str))
             _require(observed == DATASETS, f"{name}: dataset set is {sorted(observed)}", errors)
 
+    for name in (
+        "dataset_overview.csv",
+        "dataset_example_neural.csv",
+        "dataset_example_targets.csv",
+    ):
+        if name in frames:
+            observed = set(frames[name]["dataset"].dropna().astype(str))
+            _require(observed == DATASETS, f"{name}: dataset set is {sorted(observed)}", errors)
+
+    if "dataset_overview.csv" in frames:
+        overview = frames["dataset_overview.csv"]
+        _require(len(overview) == 5, "dataset overview: expected five rows", errors)
+        shown = pd.to_numeric(overview["example_features_shown"], errors="coerce")
+        _require(
+            shown.notna().all() and shown.between(1, 80).all(),
+            "dataset overview: invalid example feature counts",
+            errors,
+        )
+
+    if "dataset_example_neural.csv" in frames:
+        examples = frames["dataset_example_neural.csv"]
+        values = pd.to_numeric(examples["neural_value"], errors="coerce")
+        _require(
+            values.notna().all() and np.isfinite(values.to_numpy()).all(),
+            "dataset examples: neural values must be finite",
+            errors,
+        )
+        trials_per_dataset = examples.groupby("dataset")["trial_index"].nunique()
+        _require(
+            trials_per_dataset.eq(1).all(),
+            "dataset examples: expected one trial per dataset",
+            errors,
+        )
+
+    if "dataset_example_targets.csv" in frames:
+        targets = frames["dataset_example_targets.csv"]
+        trials_per_dataset = targets.groupby("dataset")["trial_index"].nunique()
+        _require(
+            trials_per_dataset.eq(1).all(),
+            "dataset targets: expected one trial per dataset",
+            errors,
+        )
+        classification = targets[targets["dataset"].isin({"allen_neuropixels", "speech"})]
+        _require(
+            len(classification) == 2 and classification["target_label"].notna().all(),
+            "dataset targets: classification labels are missing",
+            errors,
+        )
+
+    if all(
+        name in frames
+        for name in (
+            "dataset_overview.csv",
+            "dataset_example_neural.csv",
+            "dataset_example_targets.csv",
+        )
+    ):
+        overview_trials = frames["dataset_overview.csv"].set_index("dataset")[
+            "example_trial_index"
+        ].astype(int)
+        neural_trials = frames["dataset_example_neural.csv"].groupby("dataset")[
+            "trial_index"
+        ].first().astype(int)
+        target_trials = frames["dataset_example_targets.csv"].groupby("dataset")[
+            "trial_index"
+        ].first().astype(int)
+        _require(
+            overview_trials.equals(neural_trials.reindex(overview_trials.index))
+            and overview_trials.equals(target_trials.reindex(overview_trials.index)),
+            "dataset examples: manifest, neural and target trial indices differ",
+            errors,
+        )
+
     if "clean_prediction_summary.csv" in frames:
         prediction = frames["clean_prediction_summary.csv"]
         _require(prediction["model"].nunique() == 23, "prediction: expected 23 methods", errors)
@@ -333,6 +428,45 @@ def validate_local(data_dir: Path) -> dict[str, pd.DataFrame]:
         _require(other["auc"].notna().all(), "feature attribution: ROC-AUC values missing", errors)
         _require(feature["shap_min_value"].lt(0).any(), "feature attribution: signed negative values absent", errors)
 
+    if "neuron_attributions.csv" in frames:
+        features = frames["neuron_attributions.csv"]
+        observed = set(features["dataset"].dropna().astype(str))
+        _require(observed == DATASETS, f"neuron attributions: dataset set is {sorted(observed)}", errors)
+        _require(
+            features[["model", "dataset"]].drop_duplicates().shape[0] == 105,
+            "neuron attributions: expected 105 method-dataset pairs",
+            errors,
+        )
+        values = pd.to_numeric(features["signed_attribution"], errors="coerce")
+        _require(
+            values.notna().all() and np.isfinite(values.to_numpy()).all(),
+            "neuron attributions: signed values must be finite",
+            errors,
+        )
+        _require(
+            values.lt(0).any() and values.gt(0).any(),
+            "neuron attributions: expected positive and negative signed values",
+            errors,
+        )
+        _require(
+            set(features["attribution_bin"].dropna().astype(str))
+            == {"Top", "Middle", "Bottom", "Tied"},
+            "neuron attributions: invalid rank bins",
+            errors,
+        )
+        if "neuron_shap_summary.csv" in frames:
+            expected_counts = (
+                frames["neuron_shap_summary.csv"]
+                .set_index(["model", "dataset"])["shap_n_values"]
+                .astype(int)
+            )
+            observed_counts = features.groupby(["model", "dataset"]).size()
+            _require(
+                observed_counts.equals(expected_counts.reindex(observed_counts.index)),
+                "neuron attributions: feature counts differ from summary",
+                errors,
+            )
+
     if "trial_shapley_summary.csv" in frames:
         trial = frames["trial_shapley_summary.csv"]
         _require(set(trial["analysis"].dropna()) == {"subspace_rotation"}, "trial valuation: noncanonical analysis", errors)