from __future__ import annotations import random import statistics from collections import defaultdict from typing import Any def _mean(values: list[float]) -> float | None: return statistics.fmean(values) if values else None def bootstrap_mean_ci(values: list[float], *, seed: int = 7319, samples: int = 2000) -> list[float] | None: if not values: return None rng = random.Random(seed) estimates = [] for _ in range(samples): estimates.append(statistics.fmean(rng.choice(values) for _ in values)) estimates.sort() return [estimates[round(0.025 * (samples - 1))], estimates[round(0.975 * (samples - 1))]] def summarize_results( rows: list[dict[str, Any]], effective_threshold: float = 0.90, baseline_variant: str | None = None, ) -> dict[str, Any]: grouped: dict[tuple[str, str], list[dict[str, Any]]] = defaultdict(list) for row in rows: grouped[(str(row.get("variant")), str(row.get("lane")))].append(row) scorecards: dict[str, Any] = {} for (variant, lane), items in sorted(grouped.items()): values = [float(bool(item.get("passed"))) for item in items] wall = [float(item["telemetry"]["wall_s"]) for item in items if item.get("telemetry", {}).get("wall_s")] ttft = [float(item["telemetry"]["ttft_s"]) for item in items if item.get("telemetry", {}).get("ttft_s")] throughput = [ float(item["telemetry"]["end_to_end_tokens_per_second"]) for item in items if item.get("telemetry", {}).get("end_to_end_tokens_per_second") ] acceptance = [ float(item["telemetry"]["accepted_draft_ratio"]) for item in items if item.get("telemetry", {}).get("accepted_draft_ratio") is not None ] cached = [ float(item["telemetry"]["cached_prompt_tokens"]) for item in items if item.get("telemetry", {}).get("cached_prompt_tokens") is not None ] prefill = [ float(item["telemetry"]["prefill_tokens_per_second"]) for item in items if item.get("telemetry", {}).get("prefill_tokens_per_second") is not None ] decode = [ float(item["telemetry"]["decode_tokens_per_second"]) for item in items if item.get("telemetry", {}).get("decode_tokens_per_second") is not None ] memory = [ float(item["telemetry"]["active_memory_bytes"]) for item in items if item.get("telemetry", {}).get("active_memory_bytes") is not None ] scorecards.setdefault(variant, {})[lane] = { "cases": len(items), "passed": sum(values), "accuracy": _mean(values), "accuracy_95_ci": bootstrap_mean_ci(values), "mean_wall_s": _mean(wall), "mean_ttft_s": _mean(ttft), "mean_end_to_end_tokens_per_second": _mean(throughput), "mean_accepted_draft_ratio": _mean(acceptance), "mean_cached_prompt_tokens": _mean(cached), "mean_prefill_tokens_per_second": _mean(prefill), "mean_decode_tokens_per_second": _mean(decode), "max_active_memory_bytes": max(memory) if memory else None, } context_rows = [row for row in rows if row.get("lane") == "long-context"] context: dict[str, Any] = {} for variant in sorted({str(row.get("variant")) for row in context_rows}): selected = [row for row in context_rows if row.get("variant") == variant] cells: dict[tuple[int, float], list[float]] = defaultdict(list) family: dict[str, list[float]] = defaultdict(list) by_length: dict[int, list[float]] = defaultdict(list) by_position: dict[float, list[float]] = defaultdict(list) for row in selected: metadata = row.get("metadata") or {} length = int(metadata["target_prompt_tokens"]) position = float(metadata["requested_position"]) value = float(bool(row.get("passed"))) cells[(length, position)].append(value) family[str(metadata["family"])].append(value) by_length[length].append(value) by_position[position].append(value) length_scores = {str(key): _mean(value) for key, value in sorted(by_length.items())} qualifying = [key for key, value in by_length.items() if statistics.fmean(value) >= effective_threshold] context[variant] = { "effective_context_threshold": effective_threshold, "effective_context_length": max(qualifying) if qualifying else None, "accuracy_by_length": length_scores, "accuracy_by_position": {str(key): _mean(value) for key, value in sorted(by_position.items())}, "accuracy_by_family": {key: _mean(value) for key, value in sorted(family.items())}, "heatmap": [ {"length": length, "position": position, "accuracy": _mean(value), "trials": len(value)} for (length, position), value in sorted(cells.items()) ], "worst_cell_accuracy": min((statistics.fmean(value) for value in cells.values()), default=None), } variants = sorted({str(row.get("variant")) for row in rows}) parity: dict[str, Any] = {} if len(variants) > 1: baseline = baseline_variant or variants[0] if baseline not in variants: raise ValueError(f"Unknown baseline variant: {baseline}") baseline_rows = {row["case_id"]: row for row in rows if row.get("variant") == baseline} for variant in (item for item in variants if item != baseline): paired = [] speed_ratios = [] regressions = [] improvements = [] for row in rows: if row.get("variant") != variant or row["case_id"] not in baseline_rows: continue parent = baseline_rows[row["case_id"]] paired.append(float(bool(row.get("passed"))) - float(bool(parent.get("passed")))) if parent.get("passed") and not row.get("passed"): regressions.append({"case_id": row["case_id"], "lane": row.get("lane")}) elif row.get("passed") and not parent.get("passed"): improvements.append({"case_id": row["case_id"], "lane": row.get("lane")}) parent_speed = parent.get("telemetry", {}).get("end_to_end_tokens_per_second") candidate_speed = row.get("telemetry", {}).get("end_to_end_tokens_per_second") if parent_speed and candidate_speed: speed_ratios.append(float(candidate_speed) / float(parent_speed)) parity[variant] = { "baseline": baseline, "paired_quality_delta": _mean(paired), "paired_quality_delta_95_ci": bootstrap_mean_ci(paired), "mean_speed_ratio": _mean(speed_ratios), "paired_cases": len(paired), "zero_regression_gate": not regressions, "regressions": regressions, "improvements": improvements, } return { "schema_version": "1.0", "rows": len(rows), "scorecards": scorecards, "context": context, "parity": parity, "interpretation": { "single_intelligence_score": None, "note": "Quality, context, tools, vision, agentic reliability, and performance are reported separately.", }, }