Polish dashboard and add latent consistency views

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+*.pyc
+.cache/

README.md

@@ -6,18 +6,13 @@ app_port: 7860
 
 # BenchDash
 
-Interactive dashboard for the Tang Lab neural-behavioral benchmark summaries.
+Interactive result dashboard for the Tang Lab neural-behavioral model
+benchmark.
 
-This Space is intentionally visualization-first. It loads lightweight CSV
-exports from the benchmark repository and lets readers inspect:
+The dashboard summarizes exported benchmark results across five datasets and
+23 model variants, including clean prediction, count-noise robustness,
+cross-session latent consistency, attribution analyses, and compute cost.
 
-- clean prediction scores across models and datasets
-- robustness curves under count-noise perturbations
-- cross-recording latent consistency
-- training time and memory summaries
-- neuron-SHAP and trial-Shapley perturbation summaries
-- model runtime coverage and container assignments
-
-The Space does not train the full benchmark model suite. Full reproduction is
-container-backed, while a curated Colab companion is the right place for a
-small interactive training demo.
+The bundled files in `data/` are lightweight summary exports for interactive
+inspection. The full benchmark artifacts and reproduction workflow live in the
+main benchmark repository.

app.py

@@ -8,6 +8,7 @@ import pandas as pd
 import plotly.express as px
 import plotly.graph_objects as go
 from dash import Dash, Input, Output, dash_table, dcc, html
+from plotly.subplots import make_subplots
 
 
 DATA_DIR = Path(__file__).resolve().parent / "data"
@@ -55,7 +56,7 @@ DEFAULT_MODELS = [
 def load_csv(name: str) -> pd.DataFrame:
     path = DATA_DIR / name
     if not path.exists():
-        return pd.DataFrame()
+        raise FileNotFoundError(f"Missing bundled dashboard data: {path}")
     return pd.read_csv(path)
 
 
@@ -65,6 +66,7 @@ consistency = load_csv("consistency_summary.csv")
 scalability = load_csv("scalability_summary.csv")
 neuron_shap = load_csv("neuron_shap_summary.csv")
 trial_shapley = load_csv("trial_shapley_summary.csv")
+latent_samples = load_csv("latent_samples.csv")
 
 
 def present_rows(df: pd.DataFrame) -> pd.DataFrame:
@@ -202,6 +204,127 @@ def parse_float_list(value: object) -> list[float]:
     return out
 
 
+def latent_space_figure(dataset: str, models: list[str] | None) -> go.Figure:
+    if latent_samples.empty:
+        return empty_figure("Latent-space samples are not packaged for this build.")
+
+    chosen = selected_models(models)
+    df = latent_samples[
+        (latent_samples["dataset"].astype(str) == str(dataset))
+        & (latent_samples["model"].astype(str).isin(chosen))
+    ].copy()
+    if df.empty:
+        label = DATASET_LABELS.get(dataset, dataset)
+        return empty_figure(f"Latent-space samples are not available for {label}.")
+
+    score_df = consistency.copy()
+    if "is_active_model" in score_df.columns:
+        score_df = score_df[score_df["is_active_model"].astype(str).str.lower() == "true"]
+    score_df = score_df[
+        (score_df["dataset"].astype(str) == str(dataset))
+        & (score_df["model"].astype(str).isin(df["model"].astype(str).unique()))
+    ].copy()
+    if not score_df.empty:
+        score_df["mean_r2"] = pd.to_numeric(score_df["mean_r2"], errors="coerce")
+        plot_models = (
+            score_df.sort_values("mean_r2", ascending=False)["model"]
+            .astype(str)
+            .head(4)
+            .tolist()
+        )
+    else:
+        plot_models = sorted(df["model"].astype(str).unique())[:4]
+
+    plot_df = df[df["model"].astype(str).isin(plot_models)].copy()
+    for col in ["x", "y", "z"]:
+        plot_df[col] = pd.to_numeric(plot_df[col], errors="coerce")
+    plot_df = plot_df.dropna(subset=["x", "y", "z"])
+    if plot_df.empty:
+        return empty_figure("Latent-space samples are empty after filtering.")
+
+    score_lookup = (
+        score_df.set_index("model")["mean_r2"].to_dict() if not score_df.empty else {}
+    )
+    titles = []
+    for model in plot_models:
+        score = score_lookup.get(model)
+        suffix = "" if pd.isna(score) else f"  R2={score:.2f}"
+        titles.append(f"{model}{suffix}")
+
+    n_cols = 2
+    n_rows = int(np.ceil(len(plot_models) / n_cols))
+    fig = make_subplots(
+        rows=n_rows,
+        cols=n_cols,
+        specs=[[{"type": "scene"} for _ in range(n_cols)] for _ in range(n_rows)],
+        subplot_titles=titles,
+        horizontal_spacing=0.03,
+        vertical_spacing=0.08,
+    )
+    palette = px.colors.qualitative.Set2 + px.colors.qualitative.Dark24
+    sessions = ordered_unique(plot_df["session_label"])
+    session_colors = {session: palette[idx % len(palette)] for idx, session in enumerate(sessions)}
+
+    for model_idx, model in enumerate(plot_models):
+        model_df = plot_df[plot_df["model"].astype(str) == model]
+        row = model_idx // n_cols + 1
+        col = model_idx % n_cols + 1
+        for session in sessions:
+            session_df = model_df[model_df["session_label"].astype(str) == session]
+            if session_df.empty:
+                continue
+            fig.add_trace(
+                go.Scatter3d(
+                    x=session_df["x"],
+                    y=session_df["y"],
+                    z=session_df["z"],
+                    mode="markers",
+                    name=session,
+                    legendgroup=session,
+                    showlegend=model_idx == 0,
+                    marker=dict(
+                        size=2.4,
+                        opacity=0.58,
+                        color=session_colors[session],
+                    ),
+                    customdata=np.stack(
+                        [
+                            session_df["model"].astype(str),
+                            session_df["condition"].astype(str),
+                            session_df["trial_index"].astype(str),
+                            session_df["time_index"].astype(str),
+                        ],
+                        axis=-1,
+                    ),
+                    hovertemplate=(
+                        "model=%{customdata[0]}<br>"
+                        "session=%{fullData.name}<br>"
+                        "condition=%{customdata[1]}<br>"
+                        "trial=%{customdata[2]} time=%{customdata[3]}"
+                        "<extra></extra>"
+                    ),
+                ),
+                row=row,
+                col=col,
+            )
+
+    for idx in range(len(plot_models)):
+        scene_id = "scene" if idx == 0 else f"scene{idx + 1}"
+        fig.update_layout(
+            **{
+                scene_id: dict(
+                    xaxis=dict(title="", showgrid=False, zeroline=False, showticklabels=False),
+                    yaxis=dict(title="", showgrid=False, zeroline=False, showticklabels=False),
+                    zaxis=dict(title="", showgrid=False, zeroline=False, showticklabels=False),
+                    bgcolor="#ffffff",
+                    camera=dict(eye=dict(x=1.55, y=1.55, z=1.1)),
+                )
+            }
+        )
+    fig.update_layout(title=f"{DATASET_LABELS.get(dataset, dataset)} latent-space samples")
+    return fig_layout(fig, height=720 if n_rows > 1 else 420)
+
+
 def dataframe_table(
     table_id: str,
     *,
@@ -254,10 +377,6 @@ def panel(title: str, *children, subtitle: str | None = None) -> html.Div:
     return html.Div([html.Div(heading, className="panel-heading"), *children], className="panel")
 
 
-def code_block(text: str) -> html.Pre:
-    return html.Pre(html.Code(text), className="code-block")
-
-
 present_prediction = present_rows(prediction)
 present_cells = len(present_prediction)
 total_cells = len(prediction)
@@ -276,10 +395,10 @@ app.layout = html.Div(
                 html.Div(
                     [
                         html.Div("Tang Lab", className="eyebrow"),
-                        html.H1("BenchDash"),
+                        html.H1("Benchmark results"),
                         html.P(
-                            "Interactive summaries for the neural-behavioral model benchmark. "
-                            "The Space visualizes tracked result summaries; full training runs remain container-backed.",
+                            "Compare neural-behavioral models across prediction, robustness, "
+                            "cross-session latent geometry, attribution, and compute cost.",
                             className="lede",
                         ),
                     ],
@@ -288,12 +407,12 @@ app.layout = html.Div(
                 html.Div(
                     [
                         stat_card("Models", str(len(MODELS)), "registered benchmark methods"),
-                        stat_card("Datasets", str(len(DATASETS)), "default paper grid"),
-                        stat_card("Clean Coverage", coverage_text, f"{coverage_pct:.1f}% present"),
+                        stat_card("Datasets", str(len(DATASETS)), "neural-behavioral tasks"),
+                        stat_card("Result Coverage", coverage_text, f"{coverage_pct:.1f}% complete"),
                         stat_card(
-                            "Runtime Mix",
+                            "Compute Mix",
                             f"{runtime_counts.get('cpu', 0)} CPU / {runtime_counts.get('gpu', 0)} GPU",
-                            "from model capability metadata",
+                            "registered model runtimes",
                         ),
                     ],
                     className="stat-grid",
@@ -340,15 +459,15 @@ app.layout = html.Div(
             className="tabs",
             children=[
                 dcc.Tab(
-                    label="Prediction",
+                    label="Overview",
                     value="prediction",
                     children=[
                         panel(
-                            "Clean Prediction",
+                            "Clean Prediction Scores",
                             dcc.Graph(id="prediction-heatmap", config={"displayModeBar": False}),
                             dcc.Graph(id="prediction-ranking", config={"displayModeBar": False}),
                             dataframe_table("prediction-table"),
-                            subtitle="Task score uses R2 for regression datasets and accuracy for classification datasets.",
+                            subtitle="Scores are shown within dataset. Regression tasks use R2; classification tasks use accuracy.",
                         )
                     ],
                 ),
@@ -369,11 +488,12 @@ app.layout = html.Div(
                     value="consistency",
                     children=[
                         panel(
-                            "Cross-Recording Consistency",
+                            "Cross-Session Latent Consistency",
+                            dcc.Graph(id="latent-space", config={"displayModeBar": False}),
                             dcc.Graph(id="consistency-bars", config={"displayModeBar": False}),
                             dcc.Graph(id="consistency-heatmap", config={"displayModeBar": False}),
                             dataframe_table("consistency-table"),
-                            subtitle="Scores summarize latent alignment across sessions for datasets with multiple recordings.",
+                            subtitle="Latent clouds show sampled 3D embeddings from real consistency artifacts. Scores summarize cross-session alignment.",
                         )
                     ],
                 ),
@@ -386,7 +506,7 @@ app.layout = html.Div(
                             dcc.Graph(id="runtime-scatter", config={"displayModeBar": False}),
                             dcc.Graph(id="memory-bars", config={"displayModeBar": False}),
                             dataframe_table("runtime-table"),
-                            subtitle="Training time and memory are exported from the local benchmark artifacts.",
+                            subtitle="Training time and memory are summarized from benchmark run metadata.",
                         )
                     ],
                 ),
@@ -404,11 +524,11 @@ app.layout = html.Div(
                     ],
                 ),
                 dcc.Tab(
-                    label="Coverage",
+                    label="Methods",
                     value="coverage",
                     children=[
                         panel(
-                            "Model Coverage",
+                            "Model and Analysis Coverage",
                             dcc.Graph(id="coverage-bars", config={"displayModeBar": False}),
                             dataframe_table(
                                 "coverage-table",
@@ -416,67 +536,7 @@ app.layout = html.Div(
                                 data=model_inventory.to_dict("records"),
                                 page_size=25,
                             ),
-                            subtitle="Container labels indicate the reproducible full-suite runtime, not what this Space executes.",
-                        )
-                    ],
-                ),
-                dcc.Tab(
-                    label="Run It",
-                    value="run-it",
-                    children=[
-                        panel(
-                            "How This Is Meant To Be Used",
-                            html.Div(
-                                [
-                                    html.Div(
-                                        [
-                                            html.H3("This Space"),
-                                            html.P(
-                                                "Use BenchDash to inspect paper-result summaries, compare models, "
-                                                "check missingness, and understand runtime tradeoffs. It does not "
-                                                "train the benchmark models on Hugging Face CPU hardware."
-                                            ),
-                                        ],
-                                        className="route-card",
-                                    ),
-                                    html.Div(
-                                        [
-                                            html.H3("Colab Companion"),
-                                            html.P(
-                                                "The right notebook target is a curated subset with clean Python installs: "
-                                                "PCA, GPFA, SVC, XGBoost, CEBRA, and selected simple neural baselines."
-                                            ),
-                                        ],
-                                        className="route-card",
-                                    ),
-                                    html.Div(
-                                        [
-                                            html.H3("Full Benchmark"),
-                                            html.P(
-                                                "The full model suite should stay container-backed because several "
-                                                "upstream methods have stale pins, MATLAB Runtime requirements, or "
-                                                "CUDA/package coupling."
-                                            ),
-                                        ],
-                                        className="route-card",
-                                    ),
-                                ],
-                                className="route-grid",
-                            ),
-                            html.H3("Example container commands"),
-                            code_block(
-                                "bin/submit_local --model pca --stage comprehensive -- --dataset local_regression\n"
-                                "bin/submit_gpu --model cebra --stage comprehensive -- --dataset monkey --session sub-C_ses-CO-20151104_behavior+ecephys\n"
-                                "bin/submit_cpu --model gpfa --stage stage1 -- --dataset monkey --session sub-C_ses-CO-20151104_behavior+ecephys"
-                            ),
-                            html.H3("Canonical uploaded-data shape"),
-                            code_block(
-                                "neural:    float array, shape (N_trials, T, N_neurons)\n"
-                                "trial_ids: array, shape (N_trials,)\n"
-                                "targets:   task-dependent behavior labels or trajectories\n"
-                                "optional:  condition_ids, consistency_ids"
-                            ),
-                            subtitle="The upload/data-contract story belongs in the Colab and container path, not as the main dashboard affordance.",
+                            subtitle="Coverage reports which methods have exported benchmark summaries in this dashboard.",
                         )
                     ],
                 ),
@@ -506,8 +566,9 @@ def update_prediction(dataset: str, models: list[str] | None):
     heat_df["dataset_label"] = heat_df["dataset"].map(DATASET_LABELS).fillna(heat_df["dataset"])
     pivot = heat_df.pivot_table(index="model", columns="dataset_label", values="score", aggfunc="first")
     if not pivot.empty:
-        order = pivot.mean(axis=1, skipna=True).sort_values(ascending=False).index
-        pivot = pivot.loc[order]
+        preferred = [m for m in selected_models(models) if m in pivot.index]
+        remaining = [m for m in sorted(pivot.index.astype(str)) if m not in preferred]
+        pivot = pivot.loc[preferred + remaining]
         dataset_order = [DATASET_LABELS.get(ds, ds) for ds in DATASETS if DATASET_LABELS.get(ds, ds) in pivot.columns]
         pivot = pivot.reindex(columns=dataset_order)
     text = pivot.map(lambda x: "" if pd.isna(x) else f"{x:.3f}") if not pivot.empty else pivot
@@ -527,7 +588,7 @@ def update_prediction(dataset: str, models: list[str] | None):
             hovertemplate="model=%{y}<br>dataset=%{x}<br>score=%{z:.4f}<extra></extra>",
         )
     )
-    heatmap.update_layout(title="Clean-score matrix")
+    heatmap.update_layout(title="Clean-score matrix by dataset")
     fig_layout(heatmap, height=max(430, 28 * len(pivot.index) + 170))
 
     rank_df = present_rows(df_all)
@@ -563,7 +624,6 @@ def update_prediction(dataset: str, models: list[str] | None):
         "n_train_trials",
         "n_test_trials",
         "n_neurons",
-        "source_path",
     ]
     table_df = df_all[df_all["dataset"] == dataset].copy()
     for col in ["score", "latent_dim", "n_train_trials", "n_test_trials", "n_neurons"]:
@@ -611,7 +671,7 @@ def update_robustness(dataset: str, models: list[str] | None):
     fig.update_yaxes(title=ordered_unique(df["metric"])[0] if "metric" in df else "score")
     fig_layout(fig, height=520)
 
-    table_cols = ["model", "metric", "score_at_noise0", "score_at_max_noise", "raw_auc", "mean_score", "source_path"]
+    table_cols = ["model", "metric", "score_at_noise0", "score_at_max_noise", "raw_auc", "mean_score"]
     table_df = df[table_cols].copy()
     for col in ["score_at_noise0", "score_at_max_noise", "raw_auc", "mean_score"]:
         table_df[col] = table_df[col].map(lambda v: compact_number(v))
@@ -619,6 +679,7 @@ def update_robustness(dataset: str, models: list[str] | None):
 
 
 @app.callback(
+    Output("latent-space", "figure"),
     Output("consistency-bars", "figure"),
     Output("consistency-heatmap", "figure"),
     Output("consistency-table", "columns"),
@@ -627,33 +688,40 @@ def update_robustness(dataset: str, models: list[str] | None):
     Input("model-filter", "value"),
 )
 def update_consistency(dataset: str, models: list[str] | None):
+    latent_fig = latent_space_figure(dataset, models)
     df_all = filter_models(consistency, models)
     if "is_active_model" in df_all.columns:
         df_all = df_all[df_all["is_active_model"].astype(str).str.lower() == "true"]
     df = df_all[df_all["dataset"] == dataset].copy() if not df_all.empty else df_all
     if df.empty:
-        cols = [{"name": c, "id": c} for c in ["model", "dataset", "mean_r2_procrustes"]]
-        return empty_figure("No consistency rows for this dataset."), empty_figure("No consistency rows."), cols, []
+        cols = [{"name": c, "id": c} for c in ["model", "dataset", "mean_r2"]]
+        return (
+            latent_fig,
+            empty_figure("Consistency analysis is not available for this dataset."),
+            empty_figure("Consistency analysis is not available for this dataset."),
+            cols,
+            [],
+        )
 
-    for col in ["mean_r2", "mean_r2_procrustes"]:
-        df[col] = pd.to_numeric(df[col], errors="coerce")
-    bar_df = df.sort_values("mean_r2_procrustes", ascending=True)
+    df["mean_r2"] = pd.to_numeric(df["mean_r2"], errors="coerce")
+    bar_df = df.sort_values("mean_r2", ascending=True)
     bars = go.Figure(
         go.Bar(
-            x=bar_df["mean_r2_procrustes"],
+            x=bar_df["mean_r2"],
             y=bar_df["model"],
             orientation="h",
-            marker=dict(color=bar_df["mean_r2_procrustes"], colorscale="Bluyl"),
-            hovertemplate="model=%{y}<br>Procrustes R2=%{x:.4f}<extra></extra>",
+            marker=dict(color=bar_df["mean_r2"], colorscale="Bluyl"),
+            hovertemplate="model=%{y}<br>R2=%{x:.4f}<extra></extra>",
         )
     )
     bars.update_layout(title=f"{DATASET_LABELS.get(dataset, dataset)} cross-session alignment")
-    bars.update_xaxes(title="mean Procrustes R2")
+    bars.update_xaxes(title="mean R2")
     fig_layout(bars, height=max(420, 27 * len(bar_df) + 150))
 
     heat = df_all.copy()
+    heat["mean_r2"] = pd.to_numeric(heat["mean_r2"], errors="coerce")
     heat["dataset_label"] = heat["dataset"].map(DATASET_LABELS).fillna(heat["dataset"])
-    pivot = heat.pivot_table(index="model", columns="dataset_label", values="mean_r2_procrustes", aggfunc="first")
+    pivot = heat.pivot_table(index="model", columns="dataset_label", values="mean_r2", aggfunc="first")
     if not pivot.empty:
         pivot = pivot.loc[pivot.mean(axis=1, skipna=True).sort_values(ascending=False).index]
     text = pivot.map(lambda x: "" if pd.isna(x) else f"{x:.2f}") if not pivot.empty else pivot
@@ -678,16 +746,20 @@ def update_consistency(dataset: str, models: list[str] | None):
         "n_sessions",
         "latent_dim",
         "mean_r2",
-        "mean_r2_procrustes",
         "n_pairwise",
         "scoring_modes",
-        "source_path",
     ]
     table_df = df[[c for c in table_cols if c in df.columns]].copy()
-    for col in ["mean_r2", "mean_r2_procrustes", "latent_dim", "n_sessions", "n_pairwise"]:
+    for col in ["mean_r2", "latent_dim", "n_sessions", "n_pairwise"]:
         if col in table_df:
             table_df[col] = table_df[col].map(lambda v: compact_number(v))
-    return bars, heatmap, [{"name": c, "id": c} for c in table_df.columns], table_df.to_dict("records")
+    return (
+        latent_fig,
+        bars,
+        heatmap,
+        [{"name": c, "id": c} for c in table_df.columns],
+        table_df.to_dict("records"),
+    )
 
 
 @app.callback(
@@ -750,7 +822,6 @@ def update_runtime(dataset: str, models: list[str] | None):
         "inference_time_sec",
         "peak_ram_gb",
         "peak_vram_gb",
-        "source_path",
     ]
     table_df = df[table_cols].copy()
     for col in ["score", "training_time_sec", "inference_time_sec", "peak_ram_gb", "peak_vram_gb"]:
@@ -821,11 +892,10 @@ def update_attribution(dataset: str, models: list[str] | None):
         "spearman_corr",
         "shap_mean_value",
         "shap_fraction_positive",
-        "source_path",
     ]
     table_df = nshap[[c for c in table_cols if c in nshap.columns]].copy()
     for col in table_df.columns:
-        if col not in {"model", "dataset", "metric", "source_path"}:
+        if col not in {"model", "dataset", "metric"}:
             table_df[col] = table_df[col].map(lambda v: compact_number(v))
     return nshap_fig, tshap_fig, [{"name": c, "id": c} for c in table_df.columns], table_df.to_dict("records")
 

assets/styles.css

@@ -4,46 +4,37 @@
 
 body {
   margin: 0;
-  background: #eef3f5;
-  color: #1f2933;
+  background: #f7f8fa;
+  color: #18212b;
   font-family: Inter, Arial, sans-serif;
 }
 
 .app-shell {
   min-height: 100vh;
-  padding: 24px;
+  padding: 22px;
 }
 
 .hero {
   display: grid;
-  grid-template-columns: minmax(280px, 1fr) minmax(360px, 0.95fr);
-  gap: 20px;
-  align-items: stretch;
+  grid-template-columns: minmax(340px, 1fr) minmax(420px, 0.9fr);
+  gap: 28px;
+  align-items: end;
   margin: 0 auto 18px;
-  max-width: 1480px;
-}
-
-.hero-copy,
-.stat-card,
-.controls,
-.panel,
-.route-card {
-  background: #ffffff;
-  border: 1px solid #d8e2e8;
-  border-radius: 8px;
-  box-shadow: 0 1px 2px rgba(31, 41, 51, 0.04);
+  max-width: 1500px;
+  padding: 14px 4px 18px;
+  border-bottom: 1px solid #dfe6eb;
 }
 
 .hero-copy {
-  padding: 28px 30px;
+  min-width: 0;
 }
 
 .eyebrow {
-  color: #176b5a;
+  margin-bottom: 8px;
+  color: #536271;
   font-size: 12px;
   font-weight: 800;
   letter-spacing: 0;
-  margin-bottom: 8px;
   text-transform: uppercase;
 }
 
@@ -56,58 +47,72 @@ p {
 
 h1 {
   margin-bottom: 10px;
-  font-size: 46px;
-  line-height: 1.02;
+  font-size: 44px;
+  line-height: 1.05;
   letter-spacing: 0;
 }
 
 h2 {
   margin-bottom: 4px;
   font-size: 20px;
+  letter-spacing: 0;
 }
 
 h3 {
   margin-bottom: 8px;
-  font-size: 16px;
+  font-size: 15px;
+  letter-spacing: 0;
 }
 
 .lede {
   max-width: 760px;
   margin-bottom: 0;
-  color: #536471;
-  font-size: 17px;
-  line-height: 1.55;
+  color: #536271;
+  font-size: 16px;
+  line-height: 1.5;
 }
 
 .stat-grid {
   display: grid;
-  grid-template-columns: repeat(2, minmax(160px, 1fr));
-  gap: 12px;
+  grid-template-columns: repeat(4, minmax(110px, 1fr));
+  gap: 0;
+  align-items: end;
+  border: 1px solid #dfe6eb;
+  border-radius: 8px;
+  background: #ffffff;
 }
 
 .stat-card {
-  padding: 20px;
+  min-height: 108px;
+  padding: 18px;
+  border-right: 1px solid #e6ecef;
+}
+
+.stat-card:last-child {
+  border-right: 0;
 }
 
 .stat-label {
-  color: #536471;
-  font-size: 12px;
+  color: #617282;
+  font-size: 11px;
   font-weight: 800;
+  letter-spacing: 0;
   text-transform: uppercase;
 }
 
 .stat-value {
-  margin-top: 8px;
+  margin-top: 9px;
   color: #111827;
-  font-size: 30px;
+  font-size: 28px;
   font-weight: 800;
   line-height: 1;
 }
 
 .stat-detail {
   margin-top: 8px;
-  color: #687987;
-  font-size: 13px;
+  color: #657483;
+  font-size: 12px;
+  line-height: 1.35;
 }
 
 .controls {
@@ -115,30 +120,34 @@ h3 {
   grid-template-columns: minmax(240px, 320px) minmax(320px, 1fr);
   gap: 18px;
   margin: 0 auto 18px;
-  max-width: 1480px;
-  padding: 16px;
+  max-width: 1500px;
+  padding: 14px;
+  border: 1px solid #dfe6eb;
+  border-radius: 8px;
+  background: #ffffff;
 }
 
 .control label {
   display: block;
   margin-bottom: 7px;
-  color: #374151;
-  font-size: 13px;
+  color: #394756;
+  font-size: 12px;
   font-weight: 800;
+  letter-spacing: 0;
+  text-transform: uppercase;
 }
 
 .tabs {
   margin: 0 auto;
-  max-width: 1480px;
-}
-
-.tab {
-  border-radius: 8px 8px 0 0;
+  max-width: 1500px;
 }
 
 .panel {
-  margin-top: 16px;
+  margin-top: 14px;
   padding: 18px;
+  border: 1px solid #dfe6eb;
+  border-radius: 8px;
+  background: #ffffff;
 }
 
 .panel-heading {
@@ -147,52 +156,50 @@ h3 {
 
 .panel-subtitle {
   margin-bottom: 0;
-  color: #5d6e7d;
-  font-size: 14px;
+  color: #5b6b7b;
+  font-size: 13px;
   line-height: 1.45;
 }
 
-.route-grid {
-  display: grid;
-  grid-template-columns: repeat(3, minmax(0, 1fr));
-  gap: 14px;
-  margin-bottom: 18px;
-}
+@media (max-width: 1050px) {
+  .hero,
+  .controls {
+    grid-template-columns: 1fr;
+  }
 
-.route-card {
-  padding: 18px;
-  box-shadow: none;
-}
+  .stat-grid {
+    grid-template-columns: repeat(2, minmax(120px, 1fr));
+  }
 
-.route-card p {
-  margin-bottom: 0;
-  color: #536471;
-  line-height: 1.5;
-}
+  .stat-card:nth-child(2) {
+    border-right: 0;
+  }
 
-.code-block {
-  overflow-x: auto;
-  margin: 10px 0 22px;
-  padding: 14px 16px;
-  background: #18202a;
-  border-radius: 8px;
-  color: #e6edf2;
-  font-size: 13px;
-  line-height: 1.5;
+  .stat-card:nth-child(-n + 2) {
+    border-bottom: 1px solid #e6ecef;
+  }
 }
 
-@media (max-width: 900px) {
+@media (max-width: 680px) {
   .app-shell {
     padding: 12px;
   }
 
-  .hero,
-  .controls,
-  .route-grid {
+  h1 {
+    font-size: 34px;
+  }
+
+  .stat-grid {
     grid-template-columns: 1fr;
   }
 
-  h1 {
-    font-size: 34px;
+  .stat-card,
+  .stat-card:nth-child(2) {
+    border-right: 0;
+    border-bottom: 1px solid #e6ecef;
+  }
+
+  .stat-card:last-child {
+    border-bottom: 0;
   }
 }

requirements.txt

@@ -1,5 +1,5 @@
-dash
-gunicorn
-numpy
-pandas
-plotly
+dash>=2.17,<5
+gunicorn>=22,<24
+numpy>=1.26,<3
+pandas>=2.1,<3
+plotly>=5.22,<7