| 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.", |
| }, |
| } |
|
|
