")
# ─────────────────────────────────────────────────────────────────────────────
# MODEL BEHAVIOR SIDEBAR (moved from overview Apple-to-Apple section)
# Called from sidebar.py — zero code lost
# ─────────────────────────────────────────────────────────────────────────────
def render_model_behavior_sidebar():
"""
Full Apple-to-Apple model comparison — originally in overview.py.
Moved to sidebar under "MODEL BEHAVIOR" heading.
Every line of original logic preserved.
"""
t = _tok()
_model_cmp, _ = q_safe("""
SELECT e.model_name, e.provider, r.workflow_type,
e.task_name,
COUNT(*) AS runs,
ROUND(AVG(r.total_energy_uj)/1e6,4) AS avg_energy_j,
ROUND(AVG(r.dynamic_energy_uj)/1e6,4) AS avg_dynamic_j,
ROUND(AVG(r.duration_ns)/1e9,3) AS avg_duration_s,
ROUND(AVG(r.total_tokens),1) AS avg_tokens,
ROUND(AVG(CASE WHEN r.total_tokens>0
THEN r.total_energy_uj/r.total_tokens END)/1e3,4) AS avg_mj_per_token,
ROUND(AVG(r.ipc),3) AS avg_ipc,
ROUND(AVG(r.carbon_g)*1000,4) AS avg_carbon_mg,
ROUND(AVG(r.water_ml),4) AS avg_water_ml
FROM runs r JOIN experiments e ON r.exp_id=e.exp_id
WHERE e.model_name IS NOT NULL
GROUP BY e.model_name, e.provider, r.workflow_type, e.task_name
ORDER BY e.provider, e.model_name, r.workflow_type
""")
if _model_cmp.empty:
st.markdown(
f"
"
f"No model data yet — run experiments first.
",
unsafe_allow_html=True)
return
# ── Per-model summary cards ───────────────────────────────────────────────
_models_list = _model_cmp.model_name.dropna().unique().tolist()
for _mname in _models_list[:6]:
_mdf = _model_cmp[_model_cmp.model_name == _mname]
_mlin = _mdf[_mdf.workflow_type == "linear"].avg_energy_j.mean()
_mage = _mdf[_mdf.workflow_type == "agentic"].avg_energy_j.mean()
_mprov = str(_mdf.provider.iloc[0]) if not _mdf.empty else "?"
_mmult = _mage / _mlin if (_mlin and _mlin > 0) else 1
_pclr = "#38bdf8" if _mprov == "cloud" else "#22c55e"
_lin_s = f"{_mlin:.4f}" if (_mlin and _mlin == _mlin) else "—"
_age_s = f"{_mage:.4f}" if (_mage and _mage == _mage) else "—"
st.markdown(
f"
", unsafe_allow_html=True)
_show_cols = [c for c in [
"model_name", "provider", "workflow_type", "task_name",
"runs", "avg_energy_j", "avg_dynamic_j", "avg_duration_s",
"avg_tokens", "avg_mj_per_token", "avg_ipc",
"avg_carbon_mg", "avg_water_ml"]
if c in _model_cmp.columns]
st.dataframe(_model_cmp[_show_cols].round(4),
use_container_width=True, hide_index=True)
# ─────────────────────────────────────────────────────────────────────────────
# MAIN RENDER
# ─────────────────────────────────────────────────────────────────────────────
def render(ctx: dict):
_inject_theme()
t = _tok()
ov = ctx["ov"]
runs = ctx["runs"]
tax = ctx["tax"]
avg_lin_j = ctx["avg_lin_j"]
avg_age_j = ctx["avg_age_j"]
tax_mult = ctx["tax_mult"]
plan_ms = ctx["plan_ms"]
exec_ms = ctx["exec_ms"]
synth_ms = ctx["synth_ms"]
plan_pct = ctx["plan_pct"]
exec_pct = ctx["exec_pct"]
synth_pct = ctx["synth_pct"]
lin = ctx["lin"]
age = ctx["age"]
# ── TOPBAR ────────────────────────────────────────────────────────────────
_tcol, _tbtn = st.columns([8, 1])
with _tcol:
st.markdown(
f"
"
f"A-LEMS"
f"Agentic LLM Energy Measurement System"
f"
", unsafe_allow_html=True)
with _tbtn:
_lbl = "☀ Light" if _is_dark() else "☾ Dark"
if st.button(_lbl, key="ov_theme_toggle"):
st.session_state["theme"] = "light" if _is_dark() else "dark"
st.rerun()
# ── LIVE JOB BANNER (original — untouched) ────────────────────────────────
_live_jobs = pd.DataFrame()
try:
from gui.db import db as _db_ctx
with _db_ctx() as _lcon:
_live_jobs = pd.read_sql_query("""
SELECT
e.exp_id, e.name, e.status, e.model_name, e.provider,
e.task_name, e.runs_total, e.started_at, e.completed_at,
e.error_message,
COUNT(r.run_id) AS runs_done_actual,
COALESCE(e.runs_completed, COUNT(r.run_id)) AS runs_done,
ROUND(
100.0 * COALESCE(e.runs_completed, COUNT(r.run_id))
/ NULLIF(e.runs_total, 0), 0) AS pct_done
FROM experiments e
LEFT JOIN runs r ON r.exp_id = e.exp_id
WHERE (
e.status IN ('running', 'pending', 'started')
OR (e.status = 'completed'
AND datetime(e.completed_at) > datetime('now', '-10 minutes'))
OR (e.status = 'error'
AND datetime(COALESCE(e.completed_at, e.started_at))
> datetime('now', '-30 minutes'))
)
GROUP BY e.exp_id
ORDER BY e.started_at DESC
LIMIT 3
""", _lcon)
except Exception:
pass
if not _live_jobs.empty:
_has_running = any(s in ("running","started") for s in _live_jobs.status.values)
if _has_running:
import time as _t
if "live_last_refresh" not in st.session_state:
st.session_state.live_last_refresh = 0.0
if _t.time() - st.session_state.live_last_refresh > 4:
st.session_state.live_last_refresh = _t.time()
st.cache_data.clear()
_hdr_col, _hdr_btn = st.columns([7, 1])
with _hdr_col:
_pulse = "🟢" if _has_running else "⚫"
st.markdown(
f"
"
f"{_pulse} Live / Recent Jobs
",
unsafe_allow_html=True)
with _hdr_btn:
if st.button("↺", key="ov_live_refresh", help="Force refresh"):
st.cache_data.clear()
st.rerun()
for _, _jrow in _live_jobs.iterrows():
_jstat = str(_jrow.get("status", "?"))
_jdone = int(_jrow.get("runs_done") or 0)
_jtot = int(_jrow.get("runs_total") or 0)
_jpct = float(_jrow.get("pct_done") or 0)
_jerr = str(_jrow.get("error_message") or "")
_jclr = {"running":"#22c55e","completed":"#3b82f6",
"pending":"#f59e0b","started":"#22c55e",
"error":"#ef4444"}.get(_jstat,"#7090b0")
_jpulse = "●" if _jstat in ("running","started") else "○"
_jdur = ""
try:
import datetime as _dt
_ts = _dt.datetime.fromisoformat(
str(_jrow.get("started_at","")).replace("Z",""))
_jend_s = str(_jrow.get("completed_at") or "")
_te = (_dt.datetime.fromisoformat(_jend_s.replace("Z",""))
if _jend_s and _jend_s not in ("None","")
else _dt.datetime.now())
_sec = int((_te - _ts).total_seconds())
_jdur = f"{_sec//60}m{_sec%60:02d}s"
except Exception:
pass
_err_html = ""
if _jerr and _jerr not in ("None","") and _jstat == "error":
_err_short = _jerr[:60] + ("…" if len(_jerr) > 60 else "")
_err_html = (
f"
"
f""
f"Agentic costs "
f"{tax_mult:.1f}× more energy than linear for the same task"
f""
f"Measured across {ov.get('total_runs','—')} runs · "
f"{ov.get('total_experiments','—')} experiments"
f"
",
unsafe_allow_html=True)
# ── KPI ROW ───────────────────────────────────────────────────────────────
c1, c2, c3, c4, c5, c6 = st.columns(6)
c1.metric("Total Runs", ov.get("total_runs","—"))
c2.metric("Tax Multiple", f"{tax_mult:.1f}×",
delta=f"{(tax_mult-1)*100:.0f}% overhead", delta_color="inverse")
c3.metric("Avg Planning", f"{plan_ms:.0f}ms",
delta=f"{plan_pct:.0f}% of agentic time", delta_color="inverse")
c4.metric("Peak IPC", f"{ov.get('max_ipc', 0) or 0:.3f}")
c5.metric("Avg Carbon", f"{ov.get('avg_carbon_mg', 0) or 0:.3f}mg")
c6.metric("Total Energy", f"{ov.get('total_energy_j', 0) or 0:.1f}J")
st.markdown("", unsafe_allow_html=True)
# ── ROW 1: Energy compare | Tax by task | Recent sessions ─────────────
# All three cards use identical height (340px) + flex-column so footers align
CARD_H = "340px"
bg1 = t["bg1"]; bg2 = t["bg2"]; bg3 = t["bg3"]
t1 = t["t1"]; t2 = t["t2"]; t3 = t["t3"]
brd = t["brd"]; brd2 = t["brd2"]
def _fixed_card(body_html: str, footer_html: str,
top_color: str = "#3b82f6") -> str:
"""Card with fixed height, body scrolls, footer pinned at bottom."""
return (
f"
"
f"
{body_html}
"
f"
{footer_html}
"
f"
"
)
def _empty_row(label: str = "") -> str:
"""Phantom row — same height as a real row, invisible."""
return (
f"
"
f""
f"{label}"
f"
"
)
# ── Card 1: Linear vs Agentic ──────────────────────────────────────────────
bar_pct = f"{100/max(tax_mult,1):.0f}%"
_c1_body = (
_label("Linear vs Agentic — total energy")
+ f"
"
+ f"
"
+ f"
Linear
"
+ f"
{avg_lin_j:.3f} J
"
+ f"
baseline · 1×
"
+ f"
"
+ f"
"
+ f"
"
+ f"
"
+ f"
Agentic
"
+ f"
{avg_age_j:.3f} J
"
+ f"
overhead · {tax_mult:.1f}×
"
+ f"
"
+ f"
"
+ f"
"
# ratio bar
+ f"
Cost ratio
"
+ f"
"
+ f"
linear
"
+ f"
"
)
_c1_foot = (
f"
"
f"Extra cost: {avg_age_j-avg_lin_j:.3f} J"
f" per session — orchestration tax in absolute terms
"
)
# ── Card 2: Tax multiplier — always 6 rows ─────────────────────────────────
_tax_real_rows = []
try:
_tax_df, _ = q_safe("""
SELECT
e.task_name || ' · ' || COALESCE(e.model_name, e.provider, '?') AS label,
ROUND(AVG(
CAST(ra.total_energy_uj AS REAL) /
NULLIF(rl.total_energy_uj, 0)
), 2) AS tmult
FROM orchestration_tax_summary ots
JOIN runs rl ON ots.linear_run_id = rl.run_id
JOIN runs ra ON ots.agentic_run_id = ra.run_id
JOIN experiments e ON ra.exp_id = e.exp_id
WHERE rl.total_energy_uj > 0
GROUP BY label ORDER BY tmult DESC LIMIT 6
""")
if not _tax_df.empty:
_max_t = float(_tax_df.tmult.max()) or 1
for _, _tr in _tax_df.iterrows():
_tv = float(_tr.tmult or 0)
_tw = f"{_tv/_max_t*95:.0f}%"
_clr = "#dc2626" if _tv >= 10 else "#d97706" if _tv >= 2 else "#16a34a"
_tax_real_rows.append(
f"
"
f"
{str(_tr.label)[:20]}
"
f"
"
f"
{_tv:.1f}×
"
f"
{_tv:.1f}×
")
except Exception:
pass
_c2_body = _label("Tax multiplier by task + model")
for _row in _tax_real_rows:
_c2_body += _row
# pad to 6 rows
_empty_tax = (
f"
"
f""
f""
f"
"
)
for _ in range(6 - len(_tax_real_rows)):
_c2_body += _empty_tax
_c2_foot = f"
red >10× · amber 2–10× · green <2×
"
# ── Card 3: Recent sessions — always 6 rows ────────────────────────────────
_sess_real_rows = []
try:
_sess_df, _ = q_safe("""
SELECT e.group_id,
MAX(e.status) AS status,
COUNT(DISTINCT e.exp_id) AS n_exps,
MAX(e.created_at) AS latest
FROM experiments e
GROUP BY e.group_id
ORDER BY MAX(e.exp_id) DESC LIMIT 6
""")
_tax_by_group = {}
try:
_tg, _ = q_safe("""
SELECT e.group_id,
ROUND(AVG(CAST(ra.total_energy_uj AS REAL) /
NULLIF(rl.total_energy_uj,0)),2) AS mt
FROM orchestration_tax_summary ots
JOIN runs rl ON ots.linear_run_id = rl.run_id
JOIN runs ra ON ots.agentic_run_id = ra.run_id
JOIN experiments e ON ra.exp_id = e.exp_id
GROUP BY e.group_id
""")
if not _tg.empty:
_tax_by_group = dict(zip(_tg.group_id, _tg.mt))
except Exception:
pass
if not _sess_df.empty:
for _, _sr in _sess_df.iterrows():
_ss = str(_sr.get("status","?"))
_clr = {"completed":"#16a34a","running":"#3b82f6",
"error":"#ef4444","failed":"#ef4444"}.get(_ss,"#d97706")
_pill = (f"{_ss}")
_gid = str(_sr.get("group_id") or "")
_mt = _tax_by_group.get(_gid)
_tax_s = f"{float(_mt):.1f}×" if _mt and str(_mt) != "nan" else "—"
_short = _gid.replace("session_","")[:17]
try:
import datetime as _dt
_ago = _dt.datetime.now() - _dt.datetime.fromisoformat(
str(_sr.latest).replace("Z",""))
_s = int(_ago.total_seconds())
_ts = (f"{_s//3600}h" if _s > 3600 else
f"{_s//60}m" if _s > 60 else "now")
except Exception:
_ts = "—"
_sess_real_rows.append(
f"