Add interactive Figure 4 feature views

app.py

@@ -125,11 +125,6 @@ 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",
@@ -322,6 +317,7 @@ DOWNLOADABLE_FILES = {
     "dataset_overview.csv",
     "dataset_example_neural.csv",
     "dataset_example_targets.csv",
+    "feature_example_raster.csv",
     "clean_prediction_summary.csv",
     "robustness_summary.csv",
     "consistency_summary.csv",
@@ -422,6 +418,7 @@ def load_historical_trajectories() -> pd.DataFrame:
 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")
+feature_example_raster = load_csv("feature_example_raster.csv")
 prediction = load_csv("clean_prediction_summary.csv")
 robustness = load_csv("robustness_summary.csv")
 consistency = load_csv("consistency_summary.csv")
@@ -1402,8 +1399,8 @@ def feature_spec(dataset: str) -> tuple[str, str, str, float | None]:
     if dataset == "allen_neuropixels":
         return (
             "spearman_corr",
-            "Drifting-gratings orientation selectivity",
-            "Spearman’s r",
+            "Drifting-gratings gOSI",
+            "Spearman’s ρ",
             0.0,
         )
     if dataset == "ratinabox":
@@ -1522,161 +1519,459 @@ def feature_attribution_frame(dataset: str, model: str | None) -> pd.DataFrame:
     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_raster_figure(dataset: str) -> go.Figure:
+    frame = feature_example_raster[
+        feature_example_raster["dataset"].astype(str).eq(dataset)
+    ].copy()
+    if frame.empty:
+        return empty_figure("No example raster is available.", height=560)
+
+    numeric_columns = [
+        "trial_index",
+        "display_index",
+        "feature_index",
+        "validation_value",
+        "group_order",
+        "n_time",
+        "t0_index",
+        "bin_ms",
+    ]
+    for column in numeric_columns:
+        frame[column] = pd.to_numeric(frame[column], errors="coerce")
+    if dataset == "allen_neuropixels":
+        frame = frame.sort_values(
+            ["validation_value", "feature_index"], ascending=[False, True]
+        )
+    else:
+        frame = frame.sort_values(["group_order", "display_index"])
+
+    n_time = int(frame["n_time"].iloc[0])
+    value_columns = [f"value_{index:03d}" for index in range(n_time)]
+    raw = frame[value_columns].apply(pd.to_numeric, errors="coerce").to_numpy(dtype=float)
+    vmax = max(float(np.nanpercentile(raw, 99.5)), 1.0)
+    display = np.sqrt(np.clip(raw, 0.0, vmax) / vmax)
+    time_ms = (
+        np.arange(n_time) - int(frame["t0_index"].iloc[0])
+    ) * float(frame["bin_ms"].iloc[0])
+    feature_ids = frame["feature_index"].to_numpy(dtype=int)
+    customdata = np.empty((len(frame), n_time, 2), dtype=object)
+    customdata[:, :, 0] = feature_ids[:, None]
+    customdata[:, :, 1] = raw
+
+    figure = make_subplots(
+        rows=1,
+        cols=2,
+        shared_yaxes=True,
+        column_widths=[0.035, 0.965],
+        horizontal_spacing=0.012,
+    )
+    if dataset == "allen_neuropixels":
+        strip_values = frame["validation_value"].to_numpy(dtype=float)[:, None]
+        strip_custom = np.empty((len(frame), 1, 2), dtype=object)
+        strip_custom[:, :, 0] = feature_ids[:, None]
+        strip_custom[:, :, 1] = strip_values
+        strip = go.Heatmap(
+            z=strip_values,
+            y=np.arange(len(frame)),
+            customdata=strip_custom,
+            colorscale="Cividis",
+            zmin=float(np.nanmin(strip_values)),
+            zmax=float(np.nanmax(strip_values)),
+            showscale=False,
+            hovertemplate=(
+                "Feature=%{customdata[0]:.0f}<br>"
+                "gOSI=%{customdata[1]:.4f}<extra></extra>"
+            ),
+        )
+        strip_title = "gOSI"
+    else:
+        group_colors = FEATURE_GROUP_COLORS[dataset]
+        groups = [group for group in group_colors if group in set(frame["feature_group"])]
+        codes = frame["feature_group"].map({group: index for index, group in enumerate(groups)})
+        scale: list[list[float | str]] = []
+        for index, group in enumerate(groups):
+            lower = index / len(groups)
+            upper = (index + 1) / len(groups)
+            scale.extend([[lower, group_colors[group]], [upper, group_colors[group]]])
+        strip_values = codes.to_numpy(dtype=float)[:, None]
+        strip_custom = np.asarray(
+            [[[int(feature), str(group)]] for feature, group in zip(feature_ids, frame["feature_group"])],
+            dtype=object,
+        )
+        strip = go.Heatmap(
+            z=strip_values,
+            y=np.arange(len(frame)),
+            customdata=strip_custom,
+            colorscale=scale,
+            zmin=0,
+            zmax=max(len(groups), 1),
+            showscale=False,
+            hovertemplate=(
+                "Feature=%{customdata[0]:.0f}<br>"
+                "Group=%{customdata[1]}<extra></extra>"
+            ),
+        )
+        strip_title = "Group"
+    figure.add_trace(strip, row=1, col=1)
+
+    count_ticks = np.linspace(0.0, vmax, 5)
+    figure.add_trace(
+        go.Heatmap(
+            z=display,
+            x=time_ms,
+            y=np.arange(len(frame)),
+            customdata=customdata,
+            colorscale=[[0.0, "#FFFFFF"], [1.0, "#263238"]],
+            zmin=0,
+            zmax=1,
+            colorbar=dict(
+                title="Count",
+                thickness=11,
+                tickvals=np.sqrt(count_ticks / vmax),
+                ticktext=[f"{value:g}" for value in count_ticks],
+            ),
+            hovertemplate=(
+                "Feature=%{customdata[0]:.0f}<br>Time=%{x:.0f} ms<br>"
+                "Count=%{customdata[1]:.0f}<extra></extra>"
+            ),
+        ),
+        row=1,
+        col=2,
+    )
+    figure.add_vline(x=0, line_color="#D55E00", line_dash="dash", row=1, col=2)
+    if dataset != "allen_neuropixels":
+        for group in frame["feature_group"].drop_duplicates().astype(str):
+            indices = np.flatnonzero(frame["feature_group"].astype(str).eq(group))
+            if len(indices):
+                figure.add_annotation(
+                    x=0.01,
+                    xref="paper",
+                    y=float(indices.mean()),
+                    yref="y2",
+                    text=group,
+                    showarrow=False,
+                    xanchor="left",
+                    bgcolor="rgba(255,255,255,0.82)",
+                    font=dict(size=10, color="#334957"),
+                )
+                figure.add_hline(
+                    y=float(indices[-1]) + 0.5,
+                    line_color="#FFFFFF",
+                    line_width=1.2,
+                    row=1,
+                    col=2,
+                )
+    figure_layout(figure, height=560)
+    figure.update_layout(
+        title="Example neural activity",
+        margin=dict(l=18, r=24, t=66, b=58),
+    )
+    figure.add_annotation(
+        x=0.013,
+        y=1.035,
+        xref="paper",
+        yref="paper",
+        text=strip_title,
+        showarrow=False,
+        font=dict(size=10, color=MUTED_COLOR),
+    )
+    figure.update_xaxes(visible=False, row=1, col=1)
+    figure.update_yaxes(visible=False, autorange="reversed", row=1, col=1)
+    figure.update_xaxes(title="Time from scoring onset (ms)", row=1, col=2)
+    figure.update_yaxes(visible=False, autorange="reversed", row=1, col=2)
+    return figure
 
 
-def feature_attribution_figures(
+def feature_sorter_figure(
     dataset: str,
     model: str | None,
-    selected_rank: int | None = None,
-) -> tuple[go.Figure, go.Figure, str]:
-    frame = feature_attribution_frame(dataset, model)
+    arrangement: str = "ranked",
+) -> go.Figure:
+    frame = feature_attribution_frame(dataset, model).reset_index(drop=True)
     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,
+        return empty_figure("Select an available method to inspect feature attributions.", height=560)
+    ranked = arrangement == "ranked"
+    has_ranking = frame["signed_attribution"].nunique(dropna=True) > 1
+    if ranked and not has_ranking:
+        return empty_figure(
+            "Signed feature-attribution values are tied for this method and dataset.",
+            height=560,
+        )
+
+    n_features = len(frame)
+    values = frame["signed_attribution"].to_numpy(dtype=float)
+    ranks = frame["attribution_rank"].to_numpy(dtype=float)
+    y_low = min(float(np.nanmin(values)), 0.0)
+    y_high = max(float(np.nanmax(values)), 0.0)
+    y_span = max(y_high - y_low, 1e-6)
+    final_x = (ranks - 1.0) / max(n_features - 1, 1)
+    final_y = (values - y_low) / y_span
+    display_range = [-0.035, 1.055]
+
+    group_colors = FEATURE_GROUP_COLORS.get(dataset, {})
+    if dataset == "allen_neuropixels":
+        validation = frame["validation_value"].to_numpy(dtype=float)
+        vmin = float(np.nanmin(validation))
+        vmax = float(np.nanmax(validation))
+        scale = max(vmax - vmin, 1e-9)
+        start_x = (validation - vmin) / scale
+        feature_ids = frame["feature_index"].to_numpy(dtype=int)
+        start_y = 0.5 + (
+            ((feature_ids * 37) % 101) / 100.0 - 0.5
+        ) * 0.42
+        trace_groups = ["gOSI"]
+        trace_indices = [np.arange(n_features)]
+    else:
+        trace_groups = [
+            group for group in group_colors if group in set(frame["feature_group"])
+        ]
+        trace_indices = [
+            np.flatnonzero(frame["feature_group"].astype(str).eq(group))
+            for group in trace_groups
+        ]
+        centers = np.linspace(0.7, 0.3, len(trace_groups))
+        start_x = np.zeros(n_features, dtype=float)
+        start_y = np.zeros(n_features, dtype=float)
+        for center, indices in zip(centers, trace_indices):
+            ordered = indices[
+                np.argsort(frame.loc[indices, "feature_index"].to_numpy(), kind="stable")
+            ]
+            start_x[ordered] = np.linspace(0.0, 1.0, len(ordered))
+            lane_jitter = ((np.arange(len(ordered)) % 7) - 3) * 0.006
+            start_y[ordered] = center + lane_jitter
+
+    marker_size = 6 if n_features > 300 else (8 if n_features > 120 else 10)
+
+    def trace_for(indices: np.ndarray, group: str, x: np.ndarray, y: np.ndarray) -> go.Scatter:
+        subset = frame.iloc[indices]
+        customdata = np.asarray(
+            [
+                [
+                    int(row.feature_index),
+                    int(row.attribution_rank),
+                    float(row.signed_attribution),
+                    float(row.validation_value),
+                    str(row.feature_group),
+                    str(row.attribution_bin),
+                ]
+                for row in subset.itertuples(index=False)
+            ],
+            dtype=object,
         )
         validation_hover = (
-            "<br>Orientation selectivity=%{customdata[2]:.4f}"
+            "<br>gOSI=%{customdata[3]:.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>"
-                ),
-            )
+        group_hover = (
+            "" if dataset == "allen_neuropixels" else "<br>Group=%{customdata[4]}"
+        )
+        marker: dict = dict(
+            size=marker_size,
+            opacity=0.82,
+            line=dict(color="#FFFFFF", width=0.45),
         )
-    rank_figure.add_trace(
-        go.Scatter(
-            x=[int(selected["attribution_rank"])],
-            y=[float(selected["signed_attribution"])],
+        if dataset == "allen_neuropixels":
+            marker.update(
+                color=subset["validation_value"],
+                colorscale="Cividis",
+                cmin=float(frame["validation_value"].min()),
+                cmax=float(frame["validation_value"].max()),
+                colorbar=dict(title="gOSI", thickness=12),
+            )
+        else:
+            marker["color"] = group_colors[group]
+        rank_hover = "<br>Rank=%{customdata[1]:.0f}" if ranked and has_ranking else ""
+        return go.Scatter(
+            x=x[indices],
+            y=y[indices],
+            ids=[f"{dataset}:{int(value)}" for value in subset["feature_index"]],
             mode="markers",
-            name="Selected feature",
-            showlegend=False,
-            marker=dict(
-                color=group_colors[selected_group],
-                size=14,
-                line=dict(color="#172938", width=2.2),
-            ),
+            name=group,
+            showlegend=dataset != "allen_neuropixels",
+            marker=marker,
+            customdata=customdata,
             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>"
+                "Feature=%{customdata[0]:.0f}"
+                + group_hover
+                + rank_hover
+                + "<br>Signed Kernel SHAP=%{customdata[2]:+.5f}"
+                + validation_hover
+                + "<extra></extra>"
             ),
         )
+
+    x = final_x if ranked else start_x
+    y = final_y if ranked else start_y
+    figure = go.Figure(
+        data=[
+            trace_for(indices, group, x, y)
+            for group, indices in zip(trace_groups, trace_indices)
+        ]
     )
-    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:
+    shapes: list[dict] = []
+    annotations: list[dict] = []
+    if ranked:
         for rank_bin in ATTRIBUTION_BIN_ORDER:
-            count = int(counts.get((group, rank_bin), 0))
-            if count == 0:
+            bin_ranks = frame.loc[
+                frame["attribution_bin"].astype(str).eq(rank_bin), "attribution_rank"
+            ].to_numpy(dtype=float)
+            if not len(bin_ranks):
                 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)
+            bin_x = (bin_ranks - 1.0) / max(n_features - 1, 1)
+            shapes.append(
+                dict(
+                    type="rect",
+                    x0=float(bin_x.min()) - 0.5 / max(n_features - 1, 1),
+                    x1=float(bin_x.max()) + 0.5 / max(n_features - 1, 1),
+                    y0=display_range[0],
+                    y1=display_range[1],
+                    fillcolor=ATTRIBUTION_BIN_COLORS[rank_bin],
+                    opacity=0.045,
+                    line_width=0,
+                    layer="below",
+                )
+            )
+            annotations.append(
+                dict(
+                    x=float(bin_x.mean()),
+                    xref="x",
+                    y=1.035,
+                    yref="paper",
+                    text=f"{rank_bin} third",
+                    showarrow=False,
+                    font=dict(size=10, color="#334957"),
+                )
+            )
+        shapes.append(
+            dict(
+                type="line",
+                x0=display_range[0],
+                x1=display_range[1],
+                y0=(0.0 - y_low) / y_span,
+                y1=(0.0 - y_low) / y_span,
+                line=dict(color="#71808D", dash="dash", width=1.3),
             )
-
-    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))
+    elif dataset != "allen_neuropixels":
+        centers = np.linspace(0.7, 0.3, len(trace_groups))
+        for center, group in zip(centers, trace_groups):
+            shapes.append(
+                dict(
+                    type="rect",
+                    x0=display_range[0],
+                    x1=display_range[1],
+                    y0=center - 0.055,
+                    y1=center + 0.055,
+                    fillcolor=group_colors[group],
+                    opacity=0.08,
+                    line_width=0,
+                    layer="below",
+                )
+            )
+            annotations.append(
+                dict(
+                    x=0.012,
+                    xref="paper",
+                    y=center,
+                    yref="y",
+                    text=group,
+                    showarrow=False,
+                    xanchor="left",
+                    bgcolor="rgba(255,255,255,0.85)",
+                    font=dict(size=11, color="#334957"),
+                )
+            )
 
-    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}"
+    title = (
+        "Signed Kernel SHAP vs. rank"
+        if ranked
+        else "Continuous gOSI"
+        if dataset == "allen_neuropixels"
+        else "Features by reference group"
+    )
+    figure_layout(figure, height=560)
+    if ranked:
+        rank_ticks = np.unique(
+            np.rint(np.linspace(1, n_features, 5)).astype(int)
+        )
+        rank_tickvals = (rank_ticks - 1.0) / max(n_features - 1, 1)
+        value_ticks = np.linspace(y_low, y_high, 5)
+        value_tickvals = (value_ticks - y_low) / y_span
+        figure.update_xaxes(
+            visible=True,
+            range=display_range,
+            tickmode="array",
+            tickvals=rank_tickvals,
+            ticktext=[str(value) for value in rank_ticks],
+            title="Attribution rank",
+        )
+        figure.update_yaxes(
+            visible=True,
+            range=display_range,
+            tickmode="array",
+            tickvals=value_tickvals,
+            ticktext=[f"{value:.3g}" for value in value_ticks],
+            title="Signed Kernel SHAP value",
+        )
+    elif dataset == "allen_neuropixels":
+        ticks = np.linspace(vmin, vmax, 5)
+        tickvals = (ticks - vmin) / max(vmax - vmin, 1e-9)
+        figure.update_xaxes(
+            visible=True,
+            range=display_range,
+            tickmode="array",
+            tickvals=tickvals,
+            ticktext=[f"{value:.2f}" for value in ticks],
+            title="gOSI",
+            showgrid=False,
+        )
+        figure.update_yaxes(
+            visible=True,
+            range=display_range,
+            showticklabels=False,
+            ticks="",
+            title=" ",
+            showgrid=False,
+            zeroline=False,
+        )
+    else:
+        figure.update_xaxes(
+            visible=True,
+            range=display_range,
+            showticklabels=False,
+            ticks="",
+            title=" ",
+            showgrid=False,
+            zeroline=False,
+        )
+        figure.update_yaxes(
+            visible=True,
+            range=display_range,
+            showticklabels=False,
+            ticks="",
+            title=" ",
+            showgrid=False,
+            zeroline=False,
+        )
+    figure.update_xaxes(automargin=False)
+    figure.update_yaxes(automargin=False)
+    figure.update_layout(
+        title=title,
+        shapes=shapes,
+        annotations=annotations,
+        margin=dict(l=58, r=28, t=78, b=100),
+        uirevision=f"feature-sorter:{dataset}:{model}:{arrangement}",
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.04,
+            xanchor="left",
+            x=0,
+            font=dict(size=10),
+        ),
     )
-    if dataset == "allen_neuropixels" and pd.notna(selected["validation_value"]):
-        detail += f" · orientation selectivity {float(selected['validation_value']):.4f}"
-    return rank_figure, sankey, detail
+    return figure
 
 
 def trial_frame(dataset: str, models: Sequence[str] | None) -> pd.DataFrame:
@@ -2708,39 +3003,51 @@ app.layout = html.Div(
                                     ),
                                     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"},
+                                            html.Label("Arrange features", htmlFor="feature-arrangement"),
+                                            dcc.RadioItems(
+                                                id="feature-arrangement",
+                                                options=[
+                                                    {
+                                                        "label": "Reference annotation",
+                                                        "value": "reference",
+                                                    },
+                                                    {
+                                                        "label": "Signed SHAP ranking",
+                                                        "value": "ranked",
+                                                    },
+                                                ],
+                                                value="ranked",
+                                                inline=True,
+                                                className="arrangement-toggle",
                                             ),
                                         ],
-                                        className="control feature-rank-control",
+                                        className="control",
                                     ),
                                 ],
-                                className="inline-controls feature-controls",
+                                className="inline-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.",
+                                        "feature-raster",
+                                        "Example neural activity raster ordered by reference annotation.",
                                     ),
                                     graph_box(
-                                        "feature-sankey",
-                                        "Feature groups mapped to top, middle and bottom attribution-rank thirds.",
+                                        "feature-rank-plot",
+                                        "Interactive input-feature views showing reference annotations and signed Kernel SHAP score versus rank.",
                                     ),
                                 ],
-                                className="chart-grid two",
+                                className="chart-grid feature-story-grid",
+                            ),
+                            html.Div(
+                                [
+                                    source_link("feature_example_raster.csv", "Example raster CSV"),
+                                    source_link("neuron_attributions.csv", "Feature-level CSV"),
+                                ],
+                                className="download-grid panel-downloads",
                             ),
-                            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.",
+                            subtitle="Each dot is one input feature. Switch views to follow it from the reference annotation into the signed Kernel SHAP score-versus-rank curve.",
                             class_name="axis-feature",
                         ),
                         panel(
@@ -3033,43 +3340,70 @@ def update_feature_selector(
 
 
 @app.callback(
-    Output("feature-rank", "max"),
-    Output("feature-rank", "value"),
-    Output("feature-rank", "marks"),
-    Output("feature-rank", "disabled"),
+    Output("feature-raster", "figure"),
+    Input("dataset-filter", "value"),
+)
+def update_feature_raster(dataset: str):
+    return feature_raster_figure(dataset or DATASETS[0])
+
+
+@app.callback(
+    Output("feature-rank-plot", "figure"),
+    Output("feature-rank-plot", "clickData"),
     Input("dataset-filter", "value"),
     Input("feature-method", "value"),
-    State("feature-rank", "value"),
+    Input("feature-arrangement", "value"),
 )
-def update_feature_rank_slider(
+def update_feature_attributions(
     dataset: str,
     method: str | None,
-    current_rank: int | None,
+    arrangement: str,
 ):
-    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
+    sorter = feature_sorter_figure(
+        dataset or DATASETS[0], method, arrangement or "ranked"
+    )
+    return sorter, None
 
 
 @app.callback(
-    Output("feature-rank-plot", "figure"),
-    Output("feature-sankey", "figure"),
     Output("feature-selection-detail", "children"),
+    Input("feature-rank-plot", "clickData"),
     Input("dataset-filter", "value"),
     Input("feature-method", "value"),
-    Input("feature-rank", "value"),
+    Input("feature-arrangement", "value"),
 )
-def update_feature_attributions(
+def update_feature_selection_detail(
+    click_data: dict | None,
     dataset: str,
     method: str | None,
-    selected_rank: int | None,
+    arrangement: str,
 ):
-    return feature_attribution_figures(
-        dataset or DATASETS[0], method, selected_rank
-    )
+    instruction = (
+        "Switch views, then hover or click a dot to inspect its feature index, "
+        "signed Kernel SHAP value and reference annotation."
+    )
+    if not click_data or not click_data.get("points"):
+        return instruction
+    custom = click_data["points"][0].get("customdata")
+    if not custom or len(custom) < 6:
+        return instruction
+    frame = feature_attribution_frame(dataset or DATASETS[0], method)
+    feature_index = int(float(custom[0]))
+    selected = frame[
+        frame["feature_index"].astype(int).eq(feature_index)
+    ]
+    if selected.empty:
+        return instruction
+    row = selected.iloc[0]
+    detail = f"Feature index {feature_index}"
+    if arrangement == "ranked" and frame["signed_attribution"].nunique(dropna=True) > 1:
+        detail += f" · rank {int(row['attribution_rank'])} of {len(frame)}"
+    detail += f" · signed Kernel SHAP {float(row['signed_attribution']):+.5f}"
+    if dataset == "allen_neuropixels" and pd.notna(row["validation_value"]):
+        detail += f" · gOSI {float(row['validation_value']):.4f}"
+    else:
+        detail += f" · {row['feature_group']}"
+    return detail
 
 
 @app.callback(
@@ -3087,8 +3421,8 @@ def update_feature(dataset: str, models: list[str] | None):
     _column, _target, metric, _reference = feature_spec(dataset)
     if dataset == "allen_neuropixels":
         definition = (
-            "Spearman’s r measures association between feature-attribution values "
-            "and each unit’s drifting-gratings orientation selectivity."
+            "Spearman’s ρ measures association between feature-attribution values "
+            "and each unit’s gOSI measured from drifting gratings."
         )
     elif dataset == "ratinabox":
         definition = (

assets/styles.css

@@ -609,7 +609,7 @@ h2 {
 
 .inline-controls {
   display: grid;
-  grid-template-columns: minmax(240px, 420px) minmax(200px, 300px);
+  grid-template-columns: minmax(240px, 420px) minmax(260px, 380px);
   gap: 14px;
   align-items: end;
   margin-bottom: 12px;
@@ -623,12 +623,50 @@ h2 {
   grid-template-columns: minmax(240px, 420px);
 }
 
-.feature-controls {
-  grid-template-columns: minmax(240px, 360px) minmax(320px, 1fr);
+.arrangement-toggle {
+  display: flex;
+  width: 100%;
+  max-width: 380px;
+  overflow: hidden;
+  border: 1px solid #cbd5dd;
+  border-radius: 7px;
+  background: #ffffff;
 }
 
-.feature-rank-control {
-  padding: 0 7px 7px;
+.arrangement-toggle label {
+  position: relative;
+  flex: 1 1 0;
+  min-width: 0;
+  margin: 0;
+  padding: 9px 13px;
+  border-right: 1px solid #dce3e8;
+  color: #5a6c79;
+  cursor: pointer;
+  font-size: 12px;
+  font-weight: 700;
+  letter-spacing: 0;
+  line-height: 1.55;
+  text-transform: none;
+  text-align: center;
+  white-space: normal;
+}
+
+.arrangement-toggle label:last-child {
+  border-right: 0;
+}
+
+.arrangement-toggle input {
+  position: absolute;
+  opacity: 0;
+}
+
+.arrangement-toggle label:has(input:checked) {
+  background: #eee9f6;
+  color: #4d3880;
+}
+
+.feature-story-grid {
+  grid-template-columns: minmax(320px, 0.78fr) minmax(0, 1.42fr);
 }
 
 .feature-selection-detail {
@@ -820,6 +858,10 @@ h2 {
   .chart-grid.two {
     grid-template-columns: 1fr;
   }
+
+  .feature-story-grid {
+    grid-template-columns: 1fr;
+  }
 }
 
 @media (max-width: 820px) {

data/release_manifest.json

@@ -6,7 +6,7 @@
   "manuscript_working_version": "manuscript_v7",
   "schema_version": 1,
   "source": "paper/results, active consistency and feature-attribution artifacts, benchmark dataset arrays, and Figure 5 prediction sidecars",
-  "source_git_revision": "80def770609a52f45a835c6b62500b04cdc2b548",
+  "source_git_revision": "8524efc5a3a40f6ec43c3ab626424ac4597f49cf",
   "source_repository": "https://github.com/TangLab-UBC/behavior_benchmarking",
   "source_worktree_dirty": true,
   "tables": {
@@ -30,6 +30,10 @@
       "rows": 5,
       "sha256": "b5fc3f2db54c30d4a7c038e5df869c3f3f3a9e609b84cea72400942f94d7605e"
     },
+    "feature_example_raster.csv": {
+      "rows": 1057,
+      "sha256": "f905653af836026122424e4bc7984417512f4755412301e2c98803de5ab15215"
+    },
     "latent_samples.csv": {
       "rows": 31140,
       "sha256": "bb484c47b78bd7a7d0a2bfea94296e726aa80034f87368b32302aaba0c5aa622"

validate_data.py

@@ -54,6 +54,11 @@ REQUIRED_COLUMNS = {
         "dataset", "trial_index", "time_index", "time_ms", "target_0",
         "target_1", "target_label",
     },
+    "feature_example_raster.csv": {
+        "dataset", "trial_index", "display_index", "feature_index",
+        "feature_group", "validation_value", "group_order", "n_time",
+        "t0_index", "bin_ms",
+    },
     "clean_prediction_summary.csv": {
         "model", "dataset", "status", "metric", "score", "decoder",
     },
@@ -114,6 +119,7 @@ UNIQUE_KEYS = {
     "dataset_overview.csv": ["dataset"],
     "dataset_example_neural.csv": ["dataset", "time_index", "feature_display_index"],
     "dataset_example_targets.csv": ["dataset", "time_index"],
+    "feature_example_raster.csv": ["dataset", "feature_index"],
     "clean_prediction_summary.csv": ["model", "dataset"],
     "robustness_summary.csv": ["model", "dataset"],
     "scalability_summary.csv": ["model", "dataset"],
@@ -337,6 +343,7 @@ def validate_local(data_dir: Path) -> dict[str, pd.DataFrame]:
         "dataset_overview.csv",
         "dataset_example_neural.csv",
         "dataset_example_targets.csv",
+        "feature_example_raster.csv",
     ):
         if name in frames:
             observed = set(frames[name]["dataset"].dropna().astype(str))
@@ -375,13 +382,41 @@ def validate_local(data_dir: Path) -> dict[str, pd.DataFrame]:
             "dataset targets: expected one trial per dataset",
             errors,
         )
-        classification = targets[targets["dataset"].isin({"allen_neuropixels", "speech"})]
+        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 "feature_example_raster.csv" in frames:
+        raster = frames["feature_example_raster.csv"]
+        value_columns = sorted(
+            column for column in raster.columns if column.startswith("value_")
+        )
+        _require(
+            len(value_columns) == 300,
+            "feature raster: expected 300 time-value columns",
+            errors,
+        )
+        for dataset, group in raster.groupby("dataset"):
+            n_time = pd.to_numeric(group["n_time"], errors="coerce")
+            _require(
+                n_time.notna().all() and n_time.nunique() == 1,
+                f"feature raster: inconsistent time length for {dataset}",
+                errors,
+            )
+            if n_time.notna().all():
+                active_columns = value_columns[: int(n_time.iloc[0])]
+                active = group[active_columns].apply(pd.to_numeric, errors="coerce")
+                _require(
+                    active.notna().all().all()
+                    and np.isfinite(active.to_numpy(dtype=float)).all(),
+                    f"feature raster: nonfinite activity for {dataset}",
+                    errors,
+                )
     if all(
         name in frames
         for name in (
@@ -466,6 +501,34 @@ def validate_local(data_dir: Path) -> dict[str, pd.DataFrame]:
                 "neuron attributions: feature counts differ from summary",
                 errors,
             )
+        if "feature_example_raster.csv" in frames:
+            raster = frames["feature_example_raster.csv"]
+            raster_counts = raster.groupby("dataset")["feature_index"].nunique()
+            attribution_counts = features.groupby("dataset")["feature_index"].nunique()
+            _require(
+                raster_counts.equals(attribution_counts.reindex(raster_counts.index)),
+                "feature raster: feature counts differ from attributions",
+                errors,
+            )
+            raster_groups = raster[["dataset", "feature_index", "feature_group"]]
+            attribution_groups = features[
+                ["dataset", "feature_index", "feature_group"]
+            ].drop_duplicates()
+            merged = raster_groups.merge(
+                attribution_groups,
+                on=["dataset", "feature_index"],
+                how="outer",
+                suffixes=("_raster", "_attribution"),
+                indicator=True,
+            )
+            _require(
+                merged["_merge"].eq("both").all()
+                and merged["feature_group_raster"].eq(
+                    merged["feature_group_attribution"]
+                ).all(),
+                "feature raster: group labels differ from attributions",
+                errors,
+            )
 
     if "trial_shapley_summary.csv" in frames:
         trial = frames["trial_shapley_summary.csv"]