Stabilize latent hover and add full target spaces

app.py

@@ -193,7 +193,7 @@ CONDITION_LABELS = {
         for index, angle in enumerate([0, 45, 90, 135, 180, 225, 270, 315])
     },
     "speech": {
-        "0": "Do nothing",
+        "0": "rest",
         "1": "ban",
         "2": "choice",
         "3": "day",
@@ -217,21 +217,17 @@ DIRECTION_PALETTE = [
 ]
 DIRECTION_LEGEND_ORDER = [2, 1, 0, 7, 6, 5, 4, 3]
 DIRECTION_LEGEND_LABELS = ["0°", "45°", "90°", "135°", "180°", "225°", "270°", "315°"]
-SPEECH_PALETTE = {
-    "3": "#E69F00",
-    "2": "#56B4E9",
-    "4": "#009E73",
-    "7": "#999933",
-    "6": "#0072B2",
-    "1": "#D55E00",
-    "5": "#CC79A7",
-    "0": "#000000",
-}
-ALLEN_PALETTE = {
-    str(index): color
-    for index, color in enumerate(
-        ["#E69F00", "#56B4E9", "#009E73", "#F0E442", "#0072B2", "#D55E00", "#CC79A7", "#000000"]
-    )
+SPEECH_PALETTE = {str(index): color for index, color in enumerate(DIRECTION_PALETTE)}
+ALLEN_PALETTE = {str(index): color for index, color in enumerate(DIRECTION_PALETTE)}
+MC_PROFILE_LABELS = {
+    1: "Slow ascending ramp",
+    2: "Slow descending ramp",
+    3: "Fast ascending ramp",
+    4: "Fast descending ramp",
+    5: "Sine, 0.25 Hz",
+    6: "Sine, 1 Hz",
+    7: "Sine, 3 Hz",
+    8: "Chirp, 0–3 Hz",
 }
 RATINABOX_SCALE = [
     [0.0, "#440154"],
@@ -317,6 +313,7 @@ DOWNLOADABLE_FILES = {
     "dataset_overview.csv",
     "dataset_example_neural.csv",
     "dataset_example_targets.csv",
+    "dataset_targets.csv",
     "feature_example_raster.csv",
     "clean_prediction_summary.csv",
     "robustness_summary.csv",
@@ -348,11 +345,11 @@ TRIAL_HISTORICAL_TRAJECTORY_COLUMNS = [
 ]
 
 
-def load_csv(name: str) -> pd.DataFrame:
+def load_csv(name: str, **read_csv_kwargs) -> pd.DataFrame:
     path = DATA_DIR / name
     if not path.exists():
         raise FileNotFoundError(f"Missing dashboard data: {path}")
-    return pd.read_csv(path)
+    return pd.read_csv(path, **read_csv_kwargs)
 
 
 def load_historical_trajectories() -> pd.DataFrame:
@@ -418,6 +415,11 @@ 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")
+dataset_targets = load_csv(
+    "dataset_targets.csv",
+    dtype={"target_label": "string"},
+    low_memory=False,
+)
 feature_example_raster = load_csv("feature_example_raster.csv")
 prediction = load_csv("clean_prediction_summary.csv")
 robustness = load_csv("robustness_summary.csv")
@@ -888,14 +890,260 @@ def dataset_cards(selected_dataset: str) -> list[html.Article]:
     return cards
 
 
-def dataset_example_figures(dataset: str) -> tuple[go.Figure, go.Figure, str]:
+def target_space_graph(figure: go.Figure, label: str) -> html.Div:
+    return html.Div(
+        dcc.Graph(
+            figure=figure,
+            config={"displaylogo": False, "responsive": True},
+        ),
+        className="target-space-graph",
+        role="img",
+        **{"aria-label": label},
+    )
+
+
+def target_space_legend(items: Sequence[tuple[str, str]]) -> html.Div:
+    return html.Div(
+        [
+            html.Span(
+                [
+                    html.Span(
+                        className="target-legend-swatch",
+                        style={"backgroundColor": color},
+                    ),
+                    label,
+                ],
+                className="target-legend-item",
+            )
+            for label, color in items
+        ],
+        className="target-space-legend",
+    )
+
+
+def target_class_space(dataset: str, frame: pd.DataFrame) -> html.Div:
+    counts = frame.groupby("condition_id", sort=True).size()
+    example_class = int(frame.loc[frame["is_example"], "condition_id"].iloc[0])
+    cards = []
+    for raw_class, count in counts.items():
+        class_id = int(raw_class)
+        color = DIRECTION_PALETTE[class_id % len(DIRECTION_PALETTE)]
+        label = condition_label(dataset, class_id)
+        selected = class_id == example_class
+        if dataset == "allen_neuropixels":
+            glyph = html.Div(
+                [html.Span(className="orientation-arrow-head")],
+                className="orientation-arrow",
+                style={
+                    "backgroundColor": color,
+                    "color": color,
+                    "transform": f"rotate({-class_id * 45}deg)",
+                },
+            )
+        else:
+            glyph = html.Div(
+                label,
+                className="speech-target-word",
+                style={"color": color},
+            )
+        cards.append(
+            html.Div(
+                [
+                    html.Div(glyph, className="target-class-glyph"),
+                    (
+                        html.Div(label, className="target-class-label")
+                        if dataset == "allen_neuropixels"
+                        else None
+                    ),
+                    html.Div(f"{int(count)} trials", className="target-class-count"),
+                    html.Span("Example", className="target-example-badge") if selected else None,
+                ],
+                className=(
+                    "target-class-card target-class-card-selected"
+                    if selected
+                    else "target-class-card"
+                ),
+                style={"borderTopColor": color},
+            )
+        )
+    context = (
+        "Eight stimulus orientations"
+        if dataset == "allen_neuropixels"
+        else "Seven attempted words and rest"
+    )
+    return html.Div(
+        [
+            html.Div(
+                [
+                    html.Strong("Target space"),
+                    html.Span(f"{len(frame):,} trials · {context}"),
+                ],
+                className="dataset-viz-heading",
+            ),
+            html.Div(cards, className="target-class-grid"),
+        ],
+        className="target-space-content",
+    )
+
+
+def separated_trajectory_values(
+    frame: pd.DataFrame,
+    x_column: str,
+    y_column: str,
+) -> tuple[list[float | None], list[float | None]]:
+    x_values: list[float | None] = []
+    y_values: list[float | None] = []
+    for _, trial in frame.groupby("trial_index", sort=False):
+        trial = trial.sort_values("time_index")
+        x_values.extend(trial[x_column].astype(float).tolist())
+        y_values.extend(trial[y_column].astype(float).tolist())
+        x_values.append(None)
+        y_values.append(None)
+    return x_values, y_values
+
+
+def target_trajectory_space(dataset: str, frame: pd.DataFrame) -> html.Div:
+    for column in ["trial_index", "condition_id", "time_index", "time_ms", "target_0", "target_1"]:
+        frame[column] = pd.to_numeric(frame[column], errors="coerce")
+    example = frame[frame["is_example"]].sort_values("time_index")
+    figure = go.Figure()
+    legend_items: list[tuple[str, str]] = []
+
+    if dataset == "monkey":
+        for condition_id, group in frame.groupby("condition_id", sort=True):
+            condition_id = int(condition_id)
+            color = DIRECTION_PALETTE[condition_id % len(DIRECTION_PALETTE)]
+            x_values, y_values = separated_trajectory_values(group, "target_0", "target_1")
+            figure.add_trace(
+                go.Scattergl(
+                    x=x_values,
+                    y=y_values,
+                    mode="lines",
+                    line=dict(color=color, width=1),
+                    opacity=0.16,
+                    hoverinfo="skip",
+                    showlegend=False,
+                )
+            )
+            legend_items.append((condition_label(dataset, condition_id), color))
+        figure.add_trace(
+            go.Scattergl(
+                x=example["target_0"],
+                y=example["target_1"],
+                mode="lines",
+                line=dict(color="#102A3A", width=4),
+                customdata=example["time_ms"],
+                hovertemplate="Horizontal position=%{x:.3f}<br>Vertical position=%{y:.3f}<br>Time=%{customdata:.0f} ms<extra>Example</extra>",
+                showlegend=False,
+            )
+        )
+        figure.update_xaxes(title="Horizontal hand position")
+        figure.update_yaxes(title="Vertical hand position", scaleanchor="x", scaleratio=1)
+        caption = f"{frame['trial_index'].nunique():,} hand trajectories · color = reach direction"
+        aria_label = "All macaque hand-position targets, colored by reach direction."
+    elif dataset == "mc_pacman":
+        for condition_id, group in frame.groupby("condition_id", sort=True):
+            condition_id = int(condition_id)
+            color = DIRECTION_PALETTE[condition_id % len(DIRECTION_PALETTE)]
+            x_values, y_values = separated_trajectory_values(group, "time_ms", "target_0")
+            figure.add_trace(
+                go.Scattergl(
+                    x=x_values,
+                    y=y_values,
+                    mode="lines",
+                    line=dict(color=color, width=0.8),
+                    opacity=0.075,
+                    hoverinfo="skip",
+                    showlegend=False,
+                )
+            )
+            mean_profile = group.groupby("time_ms", sort=True)["target_0"].mean()
+            figure.add_trace(
+                go.Scatter(
+                    x=mean_profile.index,
+                    y=mean_profile.values,
+                    mode="lines",
+                    line=dict(color=color, width=2.2),
+                    hovertemplate=f"{MC_PROFILE_LABELS[condition_id]}<br>Time=%{{x:.0f}} ms<br>Mean force=%{{y:.3f}}<extra></extra>",
+                    showlegend=False,
+                )
+            )
+            legend_items.append((MC_PROFILE_LABELS[condition_id], color))
+        figure.add_trace(
+            go.Scatter(
+                x=example["time_ms"],
+                y=example["target_0"],
+                mode="lines",
+                line=dict(color="#102A3A", width=3.5),
+                hovertemplate="Time=%{x:.0f} ms<br>Force=%{y:.3f}<extra>Example</extra>",
+                showlegend=False,
+            )
+        )
+        figure.add_vline(x=0, line_color="#71808D", line_dash="dash")
+        figure.update_xaxes(title="Time from scoring onset (ms)")
+        figure.update_yaxes(title="Force")
+        caption = f"{frame['trial_index'].nunique():,} force trajectories · color = force profile"
+        aria_label = "All force targets, colored by force profile."
+    else:
+        figure.add_trace(
+            go.Histogram2d(
+                x=frame["target_0"],
+                y=frame["target_1"],
+                nbinsx=44,
+                nbinsy=44,
+                colorscale=RATINABOX_SCALE,
+                showscale=False,
+                hovertemplate="x=%{x:.3f}<br>y=%{y:.3f}<br>Samples=%{z}<extra></extra>",
+            )
+        )
+        figure.add_trace(
+            go.Scatter(
+                x=example["target_0"],
+                y=example["target_1"],
+                mode="lines",
+                line=dict(color="#FFFFFF", width=5),
+                hoverinfo="skip",
+                showlegend=False,
+            )
+        )
+        figure.add_trace(
+            go.Scatter(
+                x=example["target_0"],
+                y=example["target_1"],
+                mode="lines",
+                line=dict(color="#102A3A", width=2.5),
+                customdata=example["time_ms"],
+                hovertemplate="x=%{x:.3f}<br>y=%{y:.3f}<br>Time=%{customdata:.0f} ms<extra>Example</extra>",
+                showlegend=False,
+            )
+        )
+        figure.update_xaxes(title="x position", range=[0, 1])
+        figure.update_yaxes(title="y position", range=[0, 1], scaleanchor="x", scaleratio=1)
+        caption = f"{len(frame):,} position samples · color = occupancy density"
+        aria_label = "All simulated position targets shown as spatial occupancy density."
+
+    figure_layout(figure, height=410)
+    figure.update_layout(margin=dict(l=62, r=24, t=18, b=62), showlegend=False)
+    return html.Div(
+        [
+            html.Div(
+                [html.Strong("Target space"), html.Span(caption)],
+                className="dataset-viz-heading",
+            ),
+            target_space_graph(figure, aria_label),
+            target_space_legend(legend_items) if legend_items else None,
+        ],
+        className="target-space-content",
+    )
+
+
+def dataset_example_figures(dataset: str) -> tuple[go.Figure, html.Div, 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()
+    targets = dataset_targets[dataset_targets["dataset"].astype(str).eq(dataset)].copy()
+    targets["is_example"] = targets["is_example"].astype(str).str.lower().eq("true")
     for column in (
         "time_index",
         "time_ms",
@@ -951,101 +1199,15 @@ def dataset_example_figures(dataset: str) -> tuple[go.Figure, go.Figure, str]:
         )
     )
     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)
+    neural_figure.update_layout(margin=dict(l=58, r=62, t=18, b=62))
 
     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)
+        target_component = target_class_space(dataset, targets)
     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)
+        target_component = target_trajectory_space(dataset, targets)
 
     shown = int(metadata.example_features_shown)
     total = int(metadata.array_shape.split("×")[-1].strip())
@@ -1054,8 +1216,11 @@ def dataset_example_figures(dataset: str) -> tuple[go.Figure, go.Figure, str]:
         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
+    description = (
+        f"The highlighted target corresponds to the neural activity shown at left; "
+        f"{feature_text}."
+    )
+    return neural_figure, target_component, description
 
 
 def overview_cards(dataset: str, models: Sequence[str] | None) -> list[html.Div]:
@@ -2231,14 +2396,11 @@ def latent_space_figure(
                                 points["color_label"],
                                 points["trial_index"],
                                 points["time_index"],
+                                np.repeat(condition_name, len(points)),
                             ],
                             axis=-1,
                         ),
-                        hovertemplate=(
-                            "Recording=%{customdata[0]}<br>"
-                            f"{condition_name}=%{{customdata[1]}}<br>Trial=%{{customdata[2]}}; time bin=%{{customdata[3]}}"
-                            "<extra></extra>"
-                        ),
+                        hoverinfo="none",
                     ),
                     row=row_index,
                     col=column_index,
@@ -2254,7 +2416,7 @@ def latent_space_figure(
                             legendgroup=condition,
                             showlegend=False,
                             line=dict(color=colors[condition], width=5),
-                            hovertemplate=f"{condition_name}={label}<br>Time bin=%{{customdata}}<extra></extra>",
+                            hoverinfo="skip",
                             customdata=means["time_index"],
                         ),
                         row=row_index,
@@ -2285,14 +2447,11 @@ def latent_space_figure(
                             session_samples["color_label"],
                             session_samples["trial_index"],
                             session_samples["time_index"],
+                            np.repeat(condition_name, len(session_samples)),
                         ],
                         axis=-1,
                     ),
-                    hovertemplate=(
-                        "Recording=%{customdata[0]}<br>"
-                        f"{condition_name}=%{{customdata[1]}}<br>Trial=%{{customdata[2]}}; time bin=%{{customdata[3]}}"
-                        "<extra></extra>"
-                    ),
+                    hoverinfo="none",
                 ),
                 row=row_index,
                 col=column_index,
@@ -2598,30 +2757,41 @@ app.layout = html.Div(
                             class_name="axis-datasets",
                         ),
                         panel(
-                            "Example benchmark input and target",
+                            "Neural activity and task targets",
                             html.Div(
                                 [
-                                    graph_box(
-                                        "dataset-neural-example",
-                                        "Example trial neural activity for the selected dataset.",
+                                    html.Div(
+                                        [
+                                            html.Div(
+                                                [
+                                                    html.Strong("Example neural activity"),
+                                                    html.Span("One benchmark trial"),
+                                                ],
+                                                className="dataset-viz-heading",
+                                            ),
+                                            graph_box(
+                                                "dataset-neural-example",
+                                                "Example trial neural activity for the selected dataset.",
+                                            ),
+                                        ],
+                                        className="dataset-example-card",
                                     ),
-                                    graph_box(
-                                        "dataset-target-example",
-                                        "Paired task target for the selected example trial.",
+                                    html.Div(
+                                        id="dataset-target-space",
+                                        className="dataset-example-card",
                                     ),
                                 ],
-                                className="chart-grid two",
+                                className="dataset-example-grid",
                             ),
                             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"),
+                                    source_link("dataset_targets.csv", "All targets"),
                                 ],
                                 className="download-grid panel-downloads",
                             ),
-                            subtitle="Examples are drawn from the preprocessed arrays used in the benchmark.",
                             class_name="axis-datasets",
                         ),
                     ],
@@ -2703,6 +2873,12 @@ app.layout = html.Div(
                                 ],
                                 className="inline-controls",
                             ),
+                            html.Div(
+                                "Hover a point to inspect its recording, condition, trial and time bin.",
+                                id="latent-hover-detail",
+                                className="latent-hover-detail",
+                                **{"aria-live": "polite"},
+                            ),
                             graph_box(
                                 "latent-space",
                                 "Aligned latent representations for each recording.",
@@ -2890,10 +3066,45 @@ app.layout = html.Div(
 )
 
 
+app.clientside_callback(
+    """
+    function(desktopHover, desktopClick, mobileHover, mobileClick) {
+        const fallback = "Hover a point to inspect its recording, condition, trial and time bin.";
+        const triggered = dash_clientside.callback_context.triggered[0];
+        if (!triggered) {
+            return fallback;
+        }
+        const prop = triggered.prop_id || "";
+        let eventData = null;
+        if (prop.startsWith("latent-space-mobile.clickData")) {
+            eventData = mobileClick;
+        } else if (prop.startsWith("latent-space-mobile.hoverData")) {
+            eventData = mobileHover;
+        } else if (prop.startsWith("latent-space.clickData")) {
+            eventData = desktopClick;
+        } else {
+            eventData = desktopHover;
+        }
+        const point = eventData && eventData.points && eventData.points[0];
+        const values = point && point.customdata;
+        if (!Array.isArray(values) || values.length < 5) {
+            return fallback;
+        }
+        return `${values[0]} · ${values[4]}: ${values[1]} · Trial ${values[2]} · Time bin ${values[3]}`;
+    }
+    """,
+    Output("latent-hover-detail", "children"),
+    Input("latent-space", "hoverData"),
+    Input("latent-space", "clickData"),
+    Input("latent-space-mobile", "hoverData"),
+    Input("latent-space-mobile", "clickData"),
+)
+
+
 @app.callback(
     Output("dataset-cards", "children"),
     Output("dataset-neural-example", "figure"),
-    Output("dataset-target-example", "figure"),
+    Output("dataset-target-space", "children"),
     Output("dataset-example-description", "children"),
     Input("dataset-filter", "value"),
 )

assets/styles.css

@@ -465,6 +465,164 @@ h2 {
   content: "↗";
 }
 
+.dataset-example-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 18px;
+  align-items: stretch;
+}
+
+.dataset-example-card {
+  min-width: 0;
+  overflow: hidden;
+  border: 1px solid #e0e7eb;
+  border-radius: 9px;
+  background: #ffffff;
+}
+
+.dataset-viz-heading {
+  display: flex;
+  min-height: 58px;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 14px;
+  padding: 15px 16px 11px;
+  border-bottom: 1px solid #edf1f4;
+}
+
+.dataset-viz-heading strong {
+  color: #203442;
+  font-size: 14px;
+  font-weight: 780;
+}
+
+.dataset-viz-heading span {
+  color: #6c7d88;
+  font-size: 10px;
+  font-weight: 650;
+  text-align: right;
+}
+
+.dataset-example-card .graph-box,
+.target-space-graph {
+  overflow: visible;
+  border: 0;
+  border-radius: 0;
+}
+
+.target-class-grid {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 10px;
+  padding: 16px;
+}
+
+.target-class-card {
+  position: relative;
+  display: flex;
+  min-width: 0;
+  min-height: 154px;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  padding: 18px 8px 12px;
+  border: 1px solid #e1e7eb;
+  border-top: 4px solid;
+  border-radius: 8px;
+  background: #fbfcfd;
+  text-align: center;
+}
+
+.target-class-card-selected {
+  border-color: #183a4e;
+  box-shadow: 0 0 0 2px #183a4e inset;
+  background: #ffffff;
+}
+
+.target-class-glyph {
+  display: flex;
+  min-height: 50px;
+  align-items: center;
+  justify-content: center;
+}
+
+.orientation-arrow {
+  position: relative;
+  width: 48px;
+  height: 5px;
+  border-radius: 999px;
+}
+
+.orientation-arrow-head {
+  position: absolute;
+  top: 50%;
+  right: -1px;
+  width: 0;
+  height: 0;
+  border-top: 7px solid transparent;
+  border-bottom: 7px solid transparent;
+  border-left: 11px solid currentColor;
+  color: inherit;
+  transform: translate(5px, -50%);
+}
+
+.speech-target-word {
+  color: #213746;
+  font-size: 17px;
+  font-weight: 780;
+}
+
+.target-class-label {
+  color: #253b49;
+  font-size: 12px;
+  font-weight: 760;
+}
+
+.target-class-count {
+  color: #74848f;
+  font-size: 10px;
+}
+
+.target-example-badge {
+  position: absolute;
+  top: 7px;
+  right: 7px;
+  padding: 2px 5px;
+  border-radius: 999px;
+  background: #183a4e;
+  color: #ffffff;
+  font-size: 8px;
+  font-weight: 800;
+  letter-spacing: 0.035em;
+  text-transform: uppercase;
+}
+
+.target-space-legend {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 6px 12px;
+  padding: 4px 16px 15px;
+}
+
+.target-legend-item {
+  display: flex;
+  min-width: 0;
+  gap: 6px;
+  align-items: flex-start;
+  color: #596b77;
+  font-size: 9px;
+  line-height: 1.25;
+}
+
+.target-legend-swatch {
+  width: 9px;
+  height: 9px;
+  flex: 0 0 auto;
+  margin-top: 1px;
+  border-radius: 50%;
+}
+
 .dataset-example-note {
   margin-top: 12px;
   color: #637581;
@@ -607,6 +765,21 @@ h2 {
   margin-top: 14px !important;
 }
 
+.latent-hover-detail {
+  display: flex;
+  min-height: 40px;
+  align-items: center;
+  margin-top: 12px;
+  padding: 8px 12px;
+  border: 1px solid #d7e4e8;
+  border-radius: 7px;
+  background: #f4f9fa;
+  color: #38515e;
+  font-size: 12px;
+  font-weight: 650;
+  line-height: 1.35;
+}
+
 .latent-space-mobile,
 .latent-mobile-legend {
   display: none;
@@ -977,6 +1150,10 @@ h2 {
     grid-template-columns: 1fr;
   }
 
+  .dataset-example-grid {
+    grid-template-columns: 1fr;
+  }
+
 }
 
 @media (max-width: 820px) {
@@ -1054,6 +1231,21 @@ h2 {
 }
 
 @media (max-width: 560px) {
+  .dataset-viz-heading {
+    align-items: flex-start;
+    flex-direction: column;
+    gap: 2px;
+  }
+
+  .dataset-viz-heading span {
+    text-align: left;
+  }
+
+  .target-class-grid,
+  .target-space-legend {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+
   .heatmap-graph {
     display: none;
   }

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": "8524efc5a3a40f6ec43c3ab626424ac4597f49cf",
+  "source_git_revision": "6f4397578797a2c812f6177ee83e9df3edd00804",
   "source_repository": "https://github.com/TangLab-UBC/behavior_benchmarking",
   "source_worktree_dirty": true,
   "tables": {
@@ -30,6 +30,10 @@
       "rows": 5,
       "sha256": "b5fc3f2db54c30d4a7c038e5df869c3f3f3a9e609b84cea72400942f94d7605e"
     },
+    "dataset_targets.csv": {
+      "rows": 72260,
+      "sha256": "215f87938c8e0376a0924a096e4f672eb316b3e5199bb3f6cc58f716c847ca21"
+    },
     "feature_example_raster.csv": {
       "rows": 1057,
       "sha256": "f905653af836026122424e4bc7984417512f4755412301e2c98803de5ab15215"

validate_data.py

@@ -54,6 +54,10 @@ REQUIRED_COLUMNS = {
         "dataset", "trial_index", "time_index", "time_ms", "target_0",
         "target_1", "target_label",
     },
+    "dataset_targets.csv": {
+        "dataset", "trial_index", "trial_id", "condition_id", "target_label",
+        "time_index", "time_ms", "target_0", "target_1", "is_example",
+    },
     "feature_example_raster.csv": {
         "dataset", "trial_index", "display_index", "feature_index",
         "feature_group", "validation_value", "group_order", "n_time",
@@ -119,6 +123,7 @@ UNIQUE_KEYS = {
     "dataset_overview.csv": ["dataset"],
     "dataset_example_neural.csv": ["dataset", "time_index", "feature_display_index"],
     "dataset_example_targets.csv": ["dataset", "time_index"],
+    "dataset_targets.csv": ["dataset", "trial_index", "time_index"],
     "feature_example_raster.csv": ["dataset", "feature_index"],
     "clean_prediction_summary.csv": ["model", "dataset"],
     "robustness_summary.csv": ["model", "dataset"],
@@ -262,7 +267,7 @@ def validate_local(data_dir: Path) -> dict[str, pd.DataFrame]:
         if not path.exists():
             errors.append(f"missing required table: {path}")
             continue
-        frame = pd.read_csv(path)
+        frame = pd.read_csv(path, low_memory=False)
         missing = sorted(columns - set(frame.columns))
         _require(not missing, f"{name}: missing columns {missing}", errors)
         if missing:
@@ -343,6 +348,7 @@ def validate_local(data_dir: Path) -> dict[str, pd.DataFrame]:
         "dataset_overview.csv",
         "dataset_example_neural.csv",
         "dataset_example_targets.csv",
+        "dataset_targets.csv",
         "feature_example_raster.csv",
     ):
         if name in frames:
@@ -391,6 +397,61 @@ def validate_local(data_dir: Path) -> dict[str, pd.DataFrame]:
             errors,
         )
 
+    if "dataset_targets.csv" in frames:
+        targets = frames["dataset_targets.csv"]
+        expected_rows = {
+            "monkey": 15_950,
+            "allen_neuropixels": 598,
+            "speech": 168,
+            "mc_pacman": 40_544,
+            "ratinabox": 15_000,
+        }
+        observed_rows = targets.groupby("dataset").size().to_dict()
+        _require(
+            observed_rows == expected_rows,
+            f"all targets: row counts are {observed_rows}",
+            errors,
+        )
+        for column in ["trial_index", "condition_id", "time_index"]:
+            values = pd.to_numeric(targets[column], errors="coerce")
+            _require(
+                values.notna().all() and np.allclose(values, np.round(values)),
+                f"all targets: invalid {column} values",
+                errors,
+            )
+        example_mask = targets["is_example"].astype(str).str.lower().eq("true")
+        example_trials = targets.loc[example_mask].groupby("dataset")[
+            "trial_index"
+        ].nunique()
+        _require(
+            example_trials.reindex(sorted(DATASETS)).eq(1).all(),
+            "all targets: expected one highlighted trial per dataset",
+            errors,
+        )
+        classification = targets[targets["dataset"].isin({"allen_neuropixels", "speech"})]
+        class_sets = classification.groupby("dataset")["condition_id"].apply(
+            lambda values: set(pd.to_numeric(values, errors="coerce").astype(int))
+        )
+        _require(
+            class_sets.map(lambda values: values == set(range(8))).all()
+            and classification["target_label"].notna().all(),
+            "all targets: classification labels or class coverage differ",
+            errors,
+        )
+        continuous = targets[targets["dataset"].isin({"monkey", "mc_pacman", "ratinabox"})]
+        target_0 = pd.to_numeric(continuous["target_0"], errors="coerce")
+        _require(
+            target_0.notna().all() and np.isfinite(target_0.to_numpy()).all(),
+            "all targets: continuous target_0 values must be finite",
+            errors,
+        )
+        two_dimensional = continuous[continuous["dataset"].isin({"monkey", "ratinabox"})]
+        target_1 = pd.to_numeric(two_dimensional["target_1"], errors="coerce")
+        _require(
+            target_1.notna().all() and np.isfinite(target_1.to_numpy()).all(),
+            "all targets: two-dimensional target values must be finite",
+            errors,
+        )
     if "feature_example_raster.csv" in frames:
         raster = frames["feature_example_raster.csv"]
         value_columns = sorted(
@@ -423,6 +484,7 @@ def validate_local(data_dir: Path) -> dict[str, pd.DataFrame]:
             "dataset_overview.csv",
             "dataset_example_neural.csv",
             "dataset_example_targets.csv",
+            "dataset_targets.csv",
         )
     ):
         overview_trials = frames["dataset_overview.csv"].set_index("dataset")[
@@ -434,9 +496,15 @@ def validate_local(data_dir: Path) -> dict[str, pd.DataFrame]:
         target_trials = frames["dataset_example_targets.csv"].groupby("dataset")[
             "trial_index"
         ].first().astype(int)
+        all_targets = frames["dataset_targets.csv"]
+        all_target_mask = all_targets["is_example"].astype(str).str.lower().eq("true")
+        all_target_trials = all_targets.loc[all_target_mask].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)),
+            and overview_trials.equals(target_trials.reindex(overview_trials.index))
+            and overview_trials.equals(all_target_trials.reindex(overview_trials.index)),
             "dataset examples: manifest, neural and target trial indices differ",
             errors,
         )