From 791f7a8889cb43c057fd74bd64bc2ab3d5dcd62d Mon Sep 17 00:00:00 2001 From: Gahow Wang Date: Tue, 14 Jul 2026 16:39:38 +0800 Subject: [PATCH] Audit telemetry intervention response for tuning --- ...ervention-response-v0-protocol-20260714.md | 71 + ...tervention-response-v0-results-20260714.md | 157 + ...ention-response-v1-p1-protocol-20260714.md | 58 + runs/intervention-response-v0/analyze_p1.py | 691 ++ .../analyze_phase6.py | 520 ++ runs/intervention-response-v0/p1-audit.json | 6818 +++++++++++++++++ .../phase6-audit.json | 5121 +++++++++++++ .../intervention-response-v0/test_analysis.py | 57 + .../test_p1_analysis.py | 35 + 9 files changed, 13528 insertions(+) create mode 100644 docs/intervention-response-v0-protocol-20260714.md create mode 100644 docs/intervention-response-v0-results-20260714.md create mode 100644 docs/intervention-response-v1-p1-protocol-20260714.md create mode 100644 runs/intervention-response-v0/analyze_p1.py create mode 100644 runs/intervention-response-v0/analyze_phase6.py create mode 100644 runs/intervention-response-v0/p1-audit.json create mode 100644 runs/intervention-response-v0/phase6-audit.json create mode 100644 runs/intervention-response-v0/test_analysis.py create mode 100644 runs/intervention-response-v0/test_p1_analysis.py diff --git a/docs/intervention-response-v0-protocol-20260714.md b/docs/intervention-response-v0-protocol-20260714.md new file mode 100644 index 0000000..47742f6 --- /dev/null +++ b/docs/intervention-response-v0-protocol-20260714.md @@ -0,0 +1,71 @@ +# Telemetry intervention-response v0 protocol + +Status: **FROZEN BEFORE V0 ANALYSIS**. + +Date: 2026-07-14 (Asia/Singapore). + +## Claim boundary + +The closed residual route asked whether one absolute engine-state snapshot can +predict unmeasured configurations. V0 asks a different, narrower question: + +> Does an adjacent, controlled MNS intervention produce an early engine-state +> response that is distinguishable from same-config repeat noise? + +Passing this gate only authorizes a matched real-GPU pilot. It does not prove +that telemetry improves tuning, that any metric is a causal mediator, or that +the response transfers to a new workload, topology, or knob family. + +## Data and estimand + +- Source: Phase 6 solo-authoritative Qwen3-30B-A3B/vLLM 0.24 Layer-1 streams. +- Action pairs: primary runs at identical study hash, TP, sampling anchor, and + request-order hash, with adjacent `MNS={8,16,32,64}` values. +- Noise pairs: primary versus confirmation at the same complete config, + anchor, and request-order hash. Only primary-to-confirmation pairs are used; + confirmations are not combined into pseudo-independent all-pairs. +- Fixed early windows: 5 seconds and 10 seconds from the measured interval + start. All runs exceed 10 seconds, so early-stop censoring cannot change the + telemetry window. +- Full-run pass rate and feasibility are descriptive only because an early + stop can make full elapsed durations differ. + +The statistical unit is a run pair. Scheduler steps are summarized within a +run and are never counted as independent trials. + +## Frozen response gate + +The directly measured gate features are scheduler-step rate, decode-batch +mean, prefill-token fraction, waiting/running queue mean, KV-usage mean, and +CUDA-graph padding fraction. + +A feature qualifies at one horizon only if: + +1. at least 75% of nonzero action deltas have the same sign; +2. median absolute action delta is at least 2x the median absolute repeat + delta; and +3. at least 50% of action deltas exceed the repeat-noise absolute p95. + +V0 opens a GPU pilot only if: + +- there are exactly 17 frozen adjacent-MNS action pairs; +- there are at least 20 primary/confirmation repeat pairs; +- all identity, finite-value, counter, and ratio invariants pass; and +- at least two gate features qualify at both 5 and 10 seconds. + +Any data red flag stops the analysis before interpreting the response. + +## If V0 passes + +Register a dash0 pilot around a known scaling knee. The pilot must use the +same request sequence and arrival times, one serving job at a time, one changed +knob, randomized `A/B` versus `B/A` order, common non-censored measurement +windows, and trial-level repetitions. It must compare a response-aware next +action against an outcome-only policy under complete startup, warm-up, and +H20-hour accounting. + +## If V0 fails + +Do not add telemetry fields or train a larger model. The current Layer-1 state +does not identify even an MNS intervention above repeat noise on this task, so +the telemetry-guided tuning route remains diagnostic only. diff --git a/docs/intervention-response-v0-results-20260714.md b/docs/intervention-response-v0-results-20260714.md new file mode 100644 index 0000000..7bc2996 --- /dev/null +++ b/docs/intervention-response-v0-results-20260714.md @@ -0,0 +1,157 @@ +# Telemetry intervention-response v0/v1 results + +Date: 2026-07-14 (Asia/Singapore). + +## Decision + +**STOP before a new H20 pilot.** The current Layer-1 aggregate telemetry does +not identify a sufficiently general early response to an MNS intervention, +and it does not improve action-efficacy prediction over exact external prefix +outcomes on the available development tasks. + +This is a negative result about the present state representation and +experiment design. It does not establish that engine telemetry is useless for +tuning, and it is not held-out evidence. + +## Hypothesis and frozen test + +The tested hypothesis was: + +> With the workload and all non-MNS settings held fixed, increasing MNS causes +> a 5--10 second engine-state response that is larger than same-config repeat +> noise and that predicts whether the action makes the full run feasible. + +A response feature had to satisfy all three frozen conditions at both 5 and +10 seconds: at least 0.75 sign consistency, median absolute action effect at +least 2x the repeat median, and at least 0.50 of action deltas above the repeat +absolute p95. At least two features had to pass. A telemetry feature was +decision-relevant only if its leave-one-repeat-out balanced accuracy was at +least 0.75 and at least 0.15 above the best exact external prefix outcome. + +## What was implemented + +- A common-window analyzer over the existing per-scheduler-step Layer-1 stream. +- Exact action pairing with request-order hash, offered load, TP, load role, + and repetition held fixed. +- Same-config repeat-noise estimation without treating scheduler steps as + independent samples. +- Exact 5/10-second request-prefix outcomes using monotonic completion times. +- A one-feature leave-one-repeat-out efficacy audit; no multivariate model was + fitted to the 12 examples. +- Input hashes, stream hashes, frozen thresholds, pair-level deltas, and sanity + invariants in machine-readable audit artifacts. +- Trial-by-trial validation against the P1 manifest, plus content hashes for + every result, request file, and Layer-1 stream. + +## Experiment A: Phase-6 retrospective audit + +Phase 6 supplied 17 adjacent-MNS actions and 29 same-config +primary/confirmation pairs. No feature passed at either horizon, producing +`STOP_NO_IDENTIFIABLE_RESPONSE`. + +The confirmation sample is not a clean replication distribution: confirmations +were selectively run after disputed primary outcomes. Several same-config +pairs consequently followed radically different trajectories. This result +therefore remains a valid failure of the frozen v0 gate, but it cannot by itself +separate normal run variance from confirmation-selection bias. + +## Experiment B: prospective-repeat confirmation + +P1 supplied three pre-arranged, disjoint request bands for every cell/load. +Exact matched actions exist for TP1 `MNS 8 -> 64` and TP4 `MNS 16 -> 64`, at +low/high load and repetitions 1/2/3. This yields 12 action pairs and 24 +same-config consecutive-repeat pairs. + +The 24 adjacent repeat differences share their middle repetition within each +three-run group. They define a conservative empirical noise reference; they +are not used as 24 independent samples in an inferential test. + +The result is `STOP_NO_PROSPECTIVE_RESPONSE`: zero features passed the response +gate at either horizon. + +The strongest response was mean waiting-queue occupancy: + +| Horizon | Sign consistency | Action/repeat median | Action above repeat p95 | Gate | +|---|---:|---:|---:|---| +| 5 s | 1.000 | 1.292x | 0.167 | fail | +| 10 s | 1.000 | 2.611x | 0.250 | fail | + +The direction is real enough to merit diagnosis, but the effect is not broad +enough to guide a general action. It is large for TP4/high-load trials and +small or absent in other regimes. + +Full-run transitions contain six beneficial actions (`false -> true`) and six +non-beneficial actions (three `false -> false`, three `true -> true`). The +beneficial label is also perfectly confounded with TP4 in this small dataset, +so it cannot support a topology-general claim. + +| Horizon | Best telemetry delta | Balanced accuracy | Best external prefix delta | Balanced accuracy | Telemetry advantage | +|---|---|---:|---|---:|---:| +| 5 s | waiting queue | 0.750 | max TPOT / SLO | 0.833 | -0.083 | +| 10 s | waiting queue | 0.750 | outstanding / admitted | 0.750 | 0.000 | + +No telemetry feature reaches the preregistered `+0.15` incremental threshold. + +## What this rules out + +It rules out using the current vector of 5/10-second global means as a solid +mechanism for choosing the next config. In particular, adding these aggregates +to an LLM prompt or fitting a larger predictor would currently hide, rather +than solve, the identifiability problem. + +It does not rule out an instrumentation-aware tuner built around a deliberately +excited local system. The existing runs were designed for endpoint/fidelity +evaluation, not system identification: the MNS action is large, efficacy is +confounded with TP, repeat bands contain different requests, and global means +erase when queue buildup or service-rate changes occur. + +## Required redesign before spending H20-hours + +The next admissible experiment is a randomized, local A/B system-identification +pilot around one fixed TP and one load knee: + +1. Replay the exact same request sequence and arrival times for both endpoints. +2. Use small adjacent actions and randomized `A/B` versus `B/A` order. +3. Record event-aligned response curves, including queue growth/drain rate, + prefill/decode service rate, and per-step service time, rather than only one + global mean. +4. Separate a mechanism gate (repeatable response) from the end-to-end gate: + fewer trials or H20-hours to select a feasible near-optimal config than an + outcome-only tuner. +5. Hold out a second load/workload for the final policy comparison. + +Until that design is frozen, a wider sweep would only generate more correlated +observations and is not justified by the evidence above. + +## Reproduction + +```bash +python3 runs/intervention-response-v0/test_analysis.py +python3 runs/intervention-response-v0/test_p1_analysis.py + +python3 runs/intervention-response-v0/analyze_phase6.py \ + --metrics runs/opprof-phase6/phase6/metrics.json \ + --raw-root runs/opprof-phase6/phase6/solo-authoritative/cells \ + --output runs/intervention-response-v0/phase6-audit.json + +python3 runs/intervention-response-v0/analyze_p1.py \ + --run-root /home/gahow/phd/replayserve/runs/fidelity_p1_frontier_committed_20260714/real/p1b \ + --manifest /home/gahow/phd/replayserve/runs/fidelity_p1_frontier_committed_20260714/real/p1b/pilot-manifest.json \ + --output runs/intervention-response-v0/p1-audit.json +``` + +## Data sanity + +- Phase 6: action pairs `n=17`, repeat pairs `n=29`, trials `n=66`; MNS + action size min/max `8/32`, `3` distinct; action-state vectors `n=17`, `17` + distinct; streams `n=12`, bytes min/max `12,745,297/52,957,710`, `12` + distinct. +- P1: action pairs `n=12`, repeat pairs `n=24`, trials `n=36`; MNS action + size min/max `48/56`, `2` distinct; efficacy labels `n=12`, min/max `0/1`, + `2` distinct; streams `n=6`, bytes min/max `17,449,143/29,431,988`, `6` + distinct. +- Checked invariants: exact action request hashes and offered loads match; + all `36/36` P1 trials match the manifest; expected pair counts hold; all + deltas are finite; non-negative counters and bounded ratios hold; per-config + state vectors are not all identical; both efficacy classes are present. No + red flags were observed. diff --git a/docs/intervention-response-v1-p1-protocol-20260714.md b/docs/intervention-response-v1-p1-protocol-20260714.md new file mode 100644 index 0000000..9a3e413 --- /dev/null +++ b/docs/intervention-response-v1-p1-protocol-20260714.md @@ -0,0 +1,58 @@ +# Intervention-response v1 prospective-repeat confirmation + +Status: **FROZEN AFTER PHASE-6 V0 FAILURE AND BEFORE P1 RESPONSE ANALYSIS**. + +Date: 2026-07-14 (Asia/Singapore). + +## Why this is a new confirmation, not a relaxed V0 + +Phase-6 V0 failed its frozen global response gate. Its 29 same-config +confirmations were triggered after disputed outcomes, and the resulting noise +sample contains extreme trajectory divergence by construction. V0 remains +failed and its thresholds are unchanged. + +The already-completed P1 campaign supplies a distinct test: three +prospectively scheduled, disjoint repeat bands for every cell/load. TP1 and +TP4 use identical offered loads and exact request-order hashes across their MNS +endpoints. V1 asks whether an MNS response is identifiable against this +prospective workload-repeat noise, and whether that response predicts action +efficacy beyond exact external prefix outcomes. + +P1 is now development data. No result here is held-out or paper-facing. + +## Frozen pairs + +- Action pairs: TP1 `MNS 8 -> 64` and TP4 `MNS 16 -> 64`, at low/high load and + repeat 1/2/3. Endpoints must have identical TP, offered rate, repeat role, + and request-order hash. Expected `n=12`. +- Repeat-noise pairs: consecutive pre-arranged repeat bands within each of six + cells and low/high load: `rep1 -> rep2`, `rep2 -> rep3`. Expected `n=24`. + Repeat bands intentionally contain different requests and therefore include + workload-sampling noise rather than pretending to be identical trials. + Adjacent differences share the middle run; the gate uses their empirical + magnitude only and does not treat the 24 differences as independent samples + for a p-value or confidence interval. +- Prefix horizons: 5 and 10 seconds. Exact monotonic request completion times + and the same Layer-1 intervals are used. + +## Frozen gates + +The response-identifiability thresholds are exactly the Phase-6 V0 thresholds: +75% sign consistency, 2x median effect/repeat noise, and at least 50% of action +deltas above repeat absolute p95. At least two response features must qualify +at both horizons. + +Action efficacy is one only for an infeasible-to-feasible full-run transition. +The 12 action pairs must contain at least four examples of each class. + +For decision relevance, each individual external-outcome response feature and +each individual telemetry-response feature is evaluated by leave-one-repeat- +band-out threshold fitting. This intentionally avoids a multivariate model on +12 examples. At least one telemetry feature must, at both horizons: + +1. reach balanced accuracy at least 0.75; and +2. exceed the best external-outcome response feature by at least 0.15. + +Only if data validity, response identifiability, and incremental decision +relevance all pass does V1 open a newly registered matched GPU pilot. No +threshold or feature is changed after observing V1. diff --git a/runs/intervention-response-v0/analyze_p1.py b/runs/intervention-response-v0/analyze_p1.py new file mode 100644 index 0000000..90f44ab --- /dev/null +++ b/runs/intervention-response-v0/analyze_p1.py @@ -0,0 +1,691 @@ +#!/usr/bin/env python3 +"""Prospective-repeat confirmation of the intervention-response hypothesis. + +P1 contains three pre-arranged, disjoint request bands per cell/load. TP1 and +TP4 use matched offered loads and request sequences across their MNS endpoints. +This script asks both whether the MNS response exceeds prospective repeat noise +and whether an early telemetry delta predicts full-run action efficacy beyond +the corresponding external-outcome delta. +""" + +from __future__ import annotations + +import argparse +import hashlib +import importlib.util +import json +import math +import re +import sys +from collections import defaultdict +from pathlib import Path +from statistics import fmean +from typing import Any, Iterable, Mapping + + +HERE = Path(__file__).resolve().parent +COMMON_STATE_DIR = HERE.parent / "telemetry-residual" +sys.path.insert(0, str(COMMON_STATE_DIR)) + +from common_state import load_jsonl, summarize_engine # noqa: E402 + + +def _load_v0(): + spec = importlib.util.spec_from_file_location( + "intervention_response_phase6_v0", HERE / "analyze_phase6.py" + ) + module = importlib.util.module_from_spec(spec) + assert spec.loader is not None + spec.loader.exec_module(module) + return module + + +V0 = _load_v0() +SCHEMA = "intervention-response-p1-confirmation-v1" +HORIZONS_S = V0.HORIZONS_S +EXPECTED_ACTION_PAIRS = 12 +EXPECTED_REPEAT_PAIRS = 24 +MIN_EFFICACY_CLASS = 4 +MIN_EFFICACY_BALANCED_ACCURACY = 0.75 +MIN_EFFICACY_DELTA_OVER_OUTCOME = 0.15 +OUTCOME_FEATURES = ( + "admitted_fraction", + "completed_over_admitted", + "completed_pass_rate", + "completed_fail_fraction_of_total", + "outstanding_over_admitted", + "ttft_max_over_slo_max", + "ttft_mean_over_slo_max", + "tpot_max_over_slo", + "tpot_mean_over_slo", + "admitted_input_tokens_mean_over_limit", +) +RUN_PATTERN = re.compile(r"^(low|high)-rep([123])$") + + +def sha256_file(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as source: + for chunk in iter(lambda: source.read(1 << 20), b""): + digest.update(chunk) + return digest.hexdigest() + + +def _prefix_outcome( + result: Mapping[str, Any], + requests: list[dict[str, Any]], + horizon_s: float, +) -> dict[str, float]: + admitted = [request for request in requests if float(request["arrival_s"]) <= horizon_s] + completed = [ + request + for request in requests + if request.get("completed_elapsed_s") is not None + and float(request["completed_elapsed_s"]) <= horizon_s + ] + if not admitted: + raise ValueError("prefix contains no admitted request") + admitted_ids = {str(request["request_id"]) for request in admitted} + if any(str(request["request_id"]) not in admitted_ids for request in completed): + raise ValueError("completed request was not admitted in the prefix") + passed = sum(bool(request["slo_pass"]) for request in completed) + ttft = [float(request["ttft_ms"]) for request in completed] + tpot = [float(request["tpot_ms"]) for request in completed] + total = int(result["selection"]["count"]) + if total != len(requests): + raise ValueError("request JSONL count does not match the result") + return { + "admitted_fraction": len(admitted) / total, + "completed_over_admitted": len(completed) / len(admitted), + "completed_pass_rate": passed / max(1, len(completed)), + "completed_fail_fraction_of_total": (len(completed) - passed) / total, + "outstanding_over_admitted": (len(admitted) - len(completed)) / len(admitted), + "ttft_max_over_slo_max": max(ttft, default=0.0) / 6000.0, + "ttft_mean_over_slo_max": fmean(ttft) / 6000.0 if ttft else 0.0, + "tpot_max_over_slo": max(tpot, default=0.0) / 50.0, + "tpot_mean_over_slo": fmean(tpot) / 50.0 if tpot else 0.0, + "admitted_input_tokens_mean_over_limit": fmean( + float(request["raw_input_tokens"]) for request in admitted + ) + / 8192.0, + } + + +def load_trials( + run_root: Path, + *, + horizons_s: tuple[float, ...] = HORIZONS_S, +) -> tuple[dict[float, list[dict[str, Any]]], list[dict[str, Any]]]: + by_horizon = {horizon: [] for horizon in horizons_s} + streams = [] + for cell_dir in sorted((run_root / "cells").iterdir()): + if not cell_dir.is_dir(): + continue + stream_paths = sorted((cell_dir / "opprof").glob("*.jsonl")) + if len(stream_paths) != 1: + raise ValueError(f"{cell_dir}: expected one Layer-1 stream") + stream_path = stream_paths[0] + stream = load_jsonl(stream_path) + streams.append( + { + "path": str(stream_path.resolve()), + "sha256": sha256_file(stream_path), + "bytes": stream_path.stat().st_size, + } + ) + for run_dir in sorted(cell_dir.iterdir()): + match = RUN_PATTERN.match(run_dir.name) + if match is None: + continue + level, replicate_text = match.groups() + replicate = int(replicate_text) + result_path = run_dir / "result.json" + requests_path = run_dir / "requests.jsonl" + result = json.loads(result_path.read_text(encoding="utf-8")) + requests = load_jsonl(requests_path) + elapsed_s = float(result["interval"]["elapsed_s"]) + start_ns = int(result["interval"]["start_mono_ns"]) + for horizon_s in horizons_s: + if elapsed_s < horizon_s: + raise ValueError( + f"{result_path}: elapsed {elapsed_s} shorter than {horizon_s}s" + ) + state = V0.flatten_state( + summarize_engine( + stream, + start_ns=start_ns, + end_ns=start_ns + int(horizon_s * 1e9), + request_count=int(result["selection"]["count"]), + ) + ) + by_horizon[horizon_s].append( + { + "trial_id": str(result_path.relative_to(run_root)), + "cell": str(result["cell"]), + "tp": int(result["tp"]), + "mns": int(result["mns"]), + "level": level, + "replicate": replicate, + "offered_rate_per_gpu": float( + result["selection"]["offered_req_s_per_gpu"] + ), + "request_hash": str( + result["selection"]["request_id_order_sha256"] + ), + "request_count": int(result["selection"]["count"]), + "result_sha256": sha256_file(result_path), + "requests_sha256": sha256_file(requests_path), + "full_pass_rate": float(result["pass_rate"]), + "full_feasible": bool(result["feasible"]), + "early_stopped": bool(result["early_stopped"]), + "state": state, + "outcome": _prefix_outcome(result, requests, horizon_s), + } + ) + return by_horizon, streams + + +def validate_manifest( + trials: list[dict[str, Any]], manifest_path: Path +) -> dict[str, Any]: + manifest = json.loads(manifest_path.read_text(encoding="utf-8")) + if manifest.get("schema") != "fidelity-prefix-pilot-manifest-v1": + raise ValueError("unexpected P1 manifest schema") + cells = manifest.get("cells") + if not isinstance(cells, dict): + raise ValueError("P1 manifest has no cell mapping") + seen = set() + for trial in trials: + key = (trial["cell"], trial["level"], trial["replicate"]) + if key in seen: + raise ValueError(f"duplicate P1 trial identity: {key}") + seen.add(key) + try: + cell = cells[trial["cell"]] + selection = cell["targets"][trial["level"]]["selections"][ + f"{trial['level']}{trial['replicate']}" + ] + except (KeyError, TypeError) as error: + raise ValueError(f"trial is absent from P1 manifest: {key}") from error + if int(cell["tp"]) != trial["tp"] or int(cell["mns"]) != trial["mns"]: + raise ValueError(f"trial config disagrees with P1 manifest: {key}") + if str(selection["request_id_order_sha256"]) != trial["request_hash"]: + raise ValueError(f"trial request hash disagrees with P1 manifest: {key}") + if int(selection["selected_count"]) != trial["request_count"]: + raise ValueError(f"trial request count disagrees with P1 manifest: {key}") + if not math.isclose( + float(selection["offered_req_s_per_gpu"]), + trial["offered_rate_per_gpu"], + rel_tol=0.0, + abs_tol=1e-12, + ): + raise ValueError(f"trial offered load disagrees with P1 manifest: {key}") + expected = { + (cell_name, level, replicate) + for cell_name in cells + for level in ("low", "high") + for replicate in (1, 2, 3) + } + if seen != expected: + missing = sorted(expected - seen) + unexpected = sorted(seen - expected) + raise ValueError( + f"P1 trial/manifest coverage mismatch: missing={missing}, " + f"unexpected={unexpected}" + ) + return { + "schema": str(manifest["schema"]), + "expected_trials": len(expected), + "matched_trials": len(seen), + } + + +def _delta( + source: Mapping[str, Any], + target: Mapping[str, Any], + features: Iterable[str], +) -> dict[str, float]: + return { + feature: float(target[feature]) - float(source[feature]) + for feature in features + } + + +def _action_pair(source: Mapping[str, Any], target: Mapping[str, Any]) -> dict[str, Any]: + if source["tp"] != target["tp"]: + raise ValueError("action endpoints changed TP") + if source["level"] != target["level"] or source["replicate"] != target["replicate"]: + raise ValueError("action endpoints changed load role or repeat") + if source["request_hash"] != target["request_hash"]: + raise ValueError("action endpoints changed request sequence") + if not math.isclose( + source["offered_rate_per_gpu"], + target["offered_rate_per_gpu"], + rel_tol=0.0, + abs_tol=1e-12, + ): + raise ValueError("action endpoints changed offered load") + if source["mns"] >= target["mns"]: + raise ValueError("action must increase MNS") + beneficial = target["full_feasible"] and not source["full_feasible"] + return { + "kind": "matched_mns_increase", + "group": { + "tp": source["tp"], + "level": source["level"], + "replicate": source["replicate"], + "request_hash": source["request_hash"], + "offered_rate_per_gpu": source["offered_rate_per_gpu"], + }, + "source": { + key: source[key] + for key in ( + "trial_id", + "result_sha256", + "requests_sha256", + "cell", + "mns", + "full_pass_rate", + "full_feasible", + "early_stopped", + ) + }, + "target": { + key: target[key] + for key in ( + "trial_id", + "result_sha256", + "requests_sha256", + "cell", + "mns", + "full_pass_rate", + "full_feasible", + "early_stopped", + ) + }, + "delta_state": _delta(source["state"], target["state"], V0.ALL_FEATURES), + "delta_outcome": _delta(source["outcome"], target["outcome"], OUTCOME_FEATURES), + "full_action_efficacy": int(beneficial), + "full_feasibility_transition": ( + f"{str(source['full_feasible']).lower()}->" + f"{str(target['full_feasible']).lower()}" + ), + } + + +def _repeat_pair(source: Mapping[str, Any], target: Mapping[str, Any]) -> dict[str, Any]: + if source["cell"] != target["cell"] or source["level"] != target["level"]: + raise ValueError("repeat endpoints changed config or load role") + if target["replicate"] != source["replicate"] + 1: + raise ValueError("repeat endpoints are not consecutive pre-arranged bands") + if not math.isclose( + source["offered_rate_per_gpu"], + target["offered_rate_per_gpu"], + rel_tol=0.0, + abs_tol=1e-12, + ): + raise ValueError("repeat endpoints changed offered load") + return { + "kind": "same_config_workload_repeat", + "group": { + "cell": source["cell"], + "tp": source["tp"], + "mns": source["mns"], + "level": source["level"], + "source_replicate": source["replicate"], + "target_replicate": target["replicate"], + }, + "source": { + key: source[key] + for key in ("trial_id", "result_sha256", "requests_sha256") + }, + "target": { + key: target[key] + for key in ("trial_id", "result_sha256", "requests_sha256") + }, + "delta_state": _delta(source["state"], target["state"], V0.ALL_FEATURES), + "delta_outcome": _delta(source["outcome"], target["outcome"], OUTCOME_FEATURES), + } + + +def build_pairs( + trials: list[dict[str, Any]], +) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: + action_groups: dict[tuple[Any, ...], list[dict[str, Any]]] = defaultdict(list) + repeat_groups: dict[tuple[str, str], list[dict[str, Any]]] = defaultdict(list) + for trial in trials: + action_groups[ + ( + trial["tp"], + trial["level"], + trial["replicate"], + trial["request_hash"], + trial["offered_rate_per_gpu"], + ) + ].append(trial) + repeat_groups[(trial["cell"], trial["level"])].append(trial) + + actions = [] + for group in action_groups.values(): + if len(group) != 2: + continue + source, target = sorted(group, key=lambda trial: trial["mns"]) + actions.append(_action_pair(source, target)) + + repeats = [] + for group in repeat_groups.values(): + ordered = sorted(group, key=lambda trial: trial["replicate"]) + if len(ordered) != 3: + raise ValueError("each prospective repeat group must contain three runs") + repeats.extend( + _repeat_pair(source, target) + for source, target in zip(ordered, ordered[1:], strict=False) + ) + return actions, repeats + + +def _balanced_accuracy(labels: list[int], predictions: list[int]) -> float: + positive = [prediction for label, prediction in zip(labels, predictions) if label == 1] + negative = [prediction for label, prediction in zip(labels, predictions) if label == 0] + if not positive or not negative: + raise ValueError("balanced accuracy requires both classes") + sensitivity = sum(prediction == 1 for prediction in positive) / len(positive) + specificity = sum(prediction == 0 for prediction in negative) / len(negative) + return (sensitivity + specificity) / 2.0 + + +def _threshold_candidates(values: list[float]) -> list[float]: + unique = sorted(set(values)) + if len(unique) == 1: + return [unique[0] - 1.0, unique[0], unique[0] + 1.0] + scale = max(1.0, max(abs(value) for value in unique)) + candidates = [unique[0] - scale * 1e-6] + candidates.extend( + (left + right) / 2.0 + for left, right in zip(unique, unique[1:], strict=False) + ) + candidates.append(unique[-1] + scale * 1e-6) + return candidates + + +def _fit_threshold(values: list[float], labels: list[int]) -> tuple[float, int, float]: + best: tuple[float, int, float, float] | None = None + for threshold in _threshold_candidates(values): + for direction in (-1, 1): + predictions = [int(direction * (value - threshold) >= 0.0) for value in values] + balanced = _balanced_accuracy(labels, predictions) + accuracy = sum( + prediction == label + for prediction, label in zip(predictions, labels, strict=True) + ) / len(labels) + candidate = (balanced, accuracy, -abs(threshold), float(direction)) + if best is None or candidate > best: + best = candidate + selected_threshold = threshold + selected_direction = direction + assert best is not None + return selected_threshold, selected_direction, best[0] + + +def one_feature_leave_repeat_out( + actions: list[dict[str, Any]], + *, + delta_key: str, + features: tuple[str, ...], +) -> dict[str, Any]: + labels = [int(pair["full_action_efficacy"]) for pair in actions] + results = {} + for feature in features: + predictions = [] + held_out_labels = [] + folds = [] + for held_out in (1, 2, 3): + train = [pair for pair in actions if pair["group"]["replicate"] != held_out] + test = [pair for pair in actions if pair["group"]["replicate"] == held_out] + train_values = [float(pair[delta_key][feature]) for pair in train] + train_labels = [int(pair["full_action_efficacy"]) for pair in train] + threshold, direction, train_balanced = _fit_threshold( + train_values, train_labels + ) + test_values = [float(pair[delta_key][feature]) for pair in test] + test_predictions = [ + int(direction * (value - threshold) >= 0.0) for value in test_values + ] + test_labels = [int(pair["full_action_efficacy"]) for pair in test] + predictions.extend(test_predictions) + held_out_labels.extend(test_labels) + folds.append( + { + "held_out_replicate": held_out, + "threshold": threshold, + "direction": direction, + "train_balanced_accuracy": train_balanced, + "test_labels": test_labels, + "test_predictions": test_predictions, + } + ) + balanced = _balanced_accuracy(held_out_labels, predictions) + accuracy = sum( + prediction == label + for prediction, label in zip(predictions, held_out_labels, strict=True) + ) / len(held_out_labels) + results[feature] = { + "balanced_accuracy": balanced, + "accuracy": accuracy, + "folds": folds, + } + best_feature = max( + results, + key=lambda feature: ( + results[feature]["balanced_accuracy"], + results[feature]["accuracy"], + feature, + ), + ) + return { + "labels": V0.numeric(labels), + "positive": sum(labels), + "negative": len(labels) - sum(labels), + "features": results, + "best_feature": best_feature, + "best_balanced_accuracy": results[best_feature]["balanced_accuracy"], + "best_accuracy": results[best_feature]["accuracy"], + } + + +def analyze_horizon(trials: list[dict[str, Any]], horizon_s: float) -> dict[str, Any]: + actions, repeats = build_pairs(trials) + response = V0.response_statistics(actions, repeats) + qualifying_response = sorted( + feature for feature, item in response.items() if item["qualifies"] + ) + outcome_cv = one_feature_leave_repeat_out( + actions, + delta_key="delta_outcome", + features=OUTCOME_FEATURES, + ) + telemetry_cv = one_feature_leave_repeat_out( + actions, + delta_key="delta_state", + features=V0.GATE_FEATURES, + ) + outcome_best = float(outcome_cv["best_balanced_accuracy"]) + efficacy_qualifying = sorted( + feature + for feature, item in telemetry_cv["features"].items() + if item["balanced_accuracy"] >= MIN_EFFICACY_BALANCED_ACCURACY + and item["balanced_accuracy"] + >= outcome_best + MIN_EFFICACY_DELTA_OVER_OUTCOME + ) + action_hashes_match = all( + pair["group"]["request_hash"] for pair in actions + ) + labels = [int(pair["full_action_efficacy"]) for pair in actions] + invariants = { + "expected_action_pair_count": len(actions) == EXPECTED_ACTION_PAIRS, + "expected_repeat_pair_count": len(repeats) == EXPECTED_REPEAT_PAIRS, + "matched_action_request_hashes": action_hashes_match, + "efficacy_label_balance": ( + sum(labels) >= MIN_EFFICACY_CLASS + and len(labels) - sum(labels) >= MIN_EFFICACY_CLASS + ), + "finite_deltas": all( + math.isfinite(value) + for pair in [*actions, *repeats] + for values in (pair["delta_state"], pair["delta_outcome"]) + for value in values.values() + ), + "probabilities_bounded": all( + 0.0 <= trial["outcome"][feature] <= 1.0 + for trial in trials + for feature in ( + "admitted_fraction", + "completed_over_admitted", + "completed_pass_rate", + "completed_fail_fraction_of_total", + "outstanding_over_admitted", + "admitted_input_tokens_mean_over_limit", + ) + ), + } + red_flags = [name for name, passed in invariants.items() if not passed] + transitions = defaultdict(int) + for pair in actions: + transitions[pair["full_feasibility_transition"]] += 1 + return { + "horizon_s": horizon_s, + "actions": actions, + "repeats": repeats, + "response_statistics": response, + "qualifying_response_features": qualifying_response, + "efficacy": { + "outcome_delta": outcome_cv, + "telemetry_delta": telemetry_cv, + "telemetry_qualifying_features": efficacy_qualifying, + "minimum_balanced_accuracy": MIN_EFFICACY_BALANCED_ACCURACY, + "minimum_delta_over_best_outcome": MIN_EFFICACY_DELTA_OVER_OUTCOME, + "feasibility_transitions": dict(sorted(transitions.items())), + }, + "sanity": { + "trials": len(trials), + "action_pairs": len(actions), + "repeat_pairs": len(repeats), + "invariants": invariants, + "red_flags": red_flags, + }, + } + + +def audit(*, run_root: Path, manifest_path: Path, output_path: Path) -> dict[str, Any]: + trials_by_horizon, streams = load_trials(run_root) + manifest_validation = validate_manifest( + trials_by_horizon[min(trials_by_horizon)], manifest_path + ) + horizons = { + str(int(horizon)): analyze_horizon(trials, horizon) + for horizon, trials in sorted(trials_by_horizon.items()) + } + red_flags = sorted( + { + flag + for horizon in horizons.values() + for flag in horizon["sanity"]["red_flags"] + } + ) + stable_response = sorted( + set.intersection( + *( + set(horizon["qualifying_response_features"]) + for horizon in horizons.values() + ) + ) + ) + stable_efficacy = sorted( + set.intersection( + *( + set(horizon["efficacy"]["telemetry_qualifying_features"]) + for horizon in horizons.values() + ) + ) + ) + if red_flags: + decision = "STOP_DATA_INVALID" + elif len(stable_response) < V0.MIN_STABLE_FEATURES: + decision = "STOP_NO_PROSPECTIVE_RESPONSE" + elif not stable_efficacy: + decision = "STOP_NO_INCREMENTAL_TUNING_SIGNAL" + else: + decision = "OPEN_MATCHED_GPU_PILOT" + payload = { + "schema": SCHEMA, + "status": "COMPLETE", + "decision": decision, + "claim_boundary": ( + "Development-only confirmation on an already-consumed P1 task. " + "Passing can open a newly registered matched pilot but cannot be " + "reported as held-out tuning evidence." + ), + "frozen_gate": { + "response_thresholds_identical_to_phase6_v0": True, + "expected_action_pairs": EXPECTED_ACTION_PAIRS, + "expected_repeat_pairs": EXPECTED_REPEAT_PAIRS, + "minimum_stable_response_features": V0.MIN_STABLE_FEATURES, + "minimum_efficacy_class": MIN_EFFICACY_CLASS, + "minimum_efficacy_balanced_accuracy": MIN_EFFICACY_BALANCED_ACCURACY, + "minimum_efficacy_delta_over_best_outcome": ( + MIN_EFFICACY_DELTA_OVER_OUTCOME + ), + }, + "stable_response_features": stable_response, + "stable_incremental_efficacy_features": stable_efficacy, + "horizons": horizons, + "provenance": { + "analysis_script": str(Path(__file__).resolve()), + "analysis_script_sha256": sha256_file(Path(__file__).resolve()), + "phase6_v0_script_sha256": sha256_file(HERE / "analyze_phase6.py"), + "run_root": str(run_root.resolve()), + "manifest": str(manifest_path.resolve()), + "manifest_sha256": sha256_file(manifest_path), + "manifest_validation": manifest_validation, + "streams": streams, + }, + "sanity": { + "stream_count": len(streams), + "stream_bytes": V0.numeric(item["bytes"] for item in streams), + "red_flags": red_flags, + }, + } + output_path.parent.mkdir(parents=True, exist_ok=True) + output_path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n") + return payload + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--run-root", type=Path, required=True) + parser.add_argument("--manifest", type=Path, required=True) + parser.add_argument("--output", type=Path, required=True) + args = parser.parse_args() + payload = audit( + run_root=args.run_root, + manifest_path=args.manifest, + output_path=args.output, + ) + print( + json.dumps( + { + "decision": payload["decision"], + "stable_response_features": payload["stable_response_features"], + "stable_incremental_efficacy_features": payload[ + "stable_incremental_efficacy_features" + ], + "sanity": payload["sanity"], + }, + indent=2, + sort_keys=True, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/runs/intervention-response-v0/analyze_phase6.py b/runs/intervention-response-v0/analyze_phase6.py new file mode 100644 index 0000000..900bdb5 --- /dev/null +++ b/runs/intervention-response-v0/analyze_phase6.py @@ -0,0 +1,520 @@ +#!/usr/bin/env python3 +"""Audit whether a controlled knob change produces identifiable telemetry deltas. + +This is a development-only feasibility audit. It compares adjacent MNS +interventions at an identical TP, offered-load anchor, and request sequence +against same-config primary/confirmation repeat noise. It does not claim that +the observed response is causal or that it improves an end-to-end tuner. +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import math +import sys +from collections import defaultdict +from pathlib import Path +from statistics import median +from typing import Any, Iterable, Mapping + + +HERE = Path(__file__).resolve().parent +COMMON_STATE_DIR = HERE.parent / "telemetry-residual" +sys.path.insert(0, str(COMMON_STATE_DIR)) + +from common_state import load_jsonl, summarize_engine # noqa: E402 + + +SCHEMA = "intervention-response-audit-v0" +HORIZONS_S = (5.0, 10.0) +GATE_FEATURES = ( + "scheduler_steps_per_s", + "decode_batch_size.mean", + "prefill_token_fraction", + "queue_waiting_mean", + "queue_running_mean", + "kv_usage_mean", + "graph_padding_fraction", +) +ALL_FEATURES = ( + "scheduler_steps_per_s", + "batch_size.mean", + "batch_tokens.mean", + "decode_batch_size.mean", + "prefill_token_fraction", + "queue_waiting_mean", + "queue_running_mean", + "preemptions", + "kv_usage_mean", + "kv_usage_max", + "kv_usage_end_minus_start", + "graph_none_share", + "graph_full_share", + "graph_padding_fraction", +) +EXPECTED_ACTION_PAIRS = 17 +MIN_REPEAT_PAIRS = 20 +MIN_STABLE_FEATURES = 2 +MIN_SIGN_CONSISTENCY = 0.75 +MIN_EFFECT_TO_NOISE = 2.0 +MIN_ABOVE_NOISE_P95_FRACTION = 0.5 + + +def sha256_file(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as source: + for chunk in iter(lambda: source.read(1 << 20), b""): + digest.update(chunk) + return digest.hexdigest() + + +def numeric(values: Iterable[float]) -> dict[str, Any]: + finite = [float(value) for value in values] + if not finite: + raise ValueError("numeric summary requires at least one value") + if any(not math.isfinite(value) for value in finite): + raise ValueError("numeric summary received a non-finite value") + return { + "n": len(finite), + "min": min(finite), + "max": max(finite), + "distinct_n": len(set(finite)), + } + + +def quantile(values: Iterable[float], probability: float) -> float: + ordered = sorted(float(value) for value in values) + if not ordered: + raise ValueError("quantile requires at least one value") + if not 0.0 <= probability <= 1.0: + raise ValueError("quantile probability must be in [0, 1]") + position = probability * (len(ordered) - 1) + lower = math.floor(position) + upper = math.ceil(position) + if lower == upper: + return ordered[lower] + weight = position - lower + return ordered[lower] * (1.0 - weight) + ordered[upper] * weight + + +def flatten_state(summary: Mapping[str, Any]) -> dict[str, float]: + common = summary["common"] + engine = summary["engine_only"] + state = { + "scheduler_steps_per_s": float(common["scheduler_steps_per_s"]), + "batch_size.mean": float(common["batch_size"]["mean"]), + "batch_tokens.mean": float(common["batch_tokens"]["mean"]), + "decode_batch_size.mean": float(common["decode_batch_size"]["mean"]), + "prefill_token_fraction": float(common["prefill_token_fraction"]), + "queue_waiting_mean": float(common["queue_waiting_mean"]), + "queue_running_mean": float(common["queue_running_mean"]), + "preemptions": float(common["preemptions"]), + "kv_usage_mean": float(engine["kv_usage_mean"]), + "kv_usage_max": float(engine["kv_usage_max"]), + "kv_usage_end_minus_start": float(engine["kv_usage_end_minus_start"]), + "graph_none_share": float(engine["graph_none_share"]), + "graph_full_share": float(engine["graph_full_share"]), + "graph_padding_fraction": float(engine["graph_padding_fraction"]), + } + if set(state) != set(ALL_FEATURES): + raise ValueError("flattened state does not match the frozen feature set") + if any(not math.isfinite(value) for value in state.values()): + raise ValueError("flattened state contains a non-finite value") + return state + + +def _trial_role(path: Path) -> str: + return "confirmation" if path.parent.name.startswith("confirm-") else "primary" + + +def load_trials( + raw_root: Path, + *, + horizons_s: tuple[float, ...] = HORIZONS_S, +) -> tuple[dict[float, list[dict[str, Any]]], list[dict[str, Any]]]: + by_horizon = {horizon: [] for horizon in horizons_s} + stream_provenance = [] + for cell_dir in sorted(path for path in raw_root.iterdir() if path.is_dir()): + streams = sorted((cell_dir / "opprof").glob("*.jsonl")) + if len(streams) != 1: + raise ValueError(f"{cell_dir}: expected exactly one Layer-1 stream") + stream = streams[0] + records = load_jsonl(stream) + stream_provenance.append( + { + "path": str(stream), + "sha256": sha256_file(stream), + "bytes": stream.stat().st_size, + } + ) + result_paths = sorted(cell_dir.glob("anchor-*/result.json")) + result_paths.extend(sorted(cell_dir.glob("confirm-*-anchor-*/result.json"))) + for result_path in result_paths: + result = json.loads(result_path.read_text(encoding="utf-8")) + start_ns = int(result["interval"]["start_mono_ns"]) + elapsed_s = float(result["interval"]["elapsed_s"]) + for horizon_s in horizons_s: + if elapsed_s < horizon_s: + raise ValueError( + f"{result_path}: elapsed {elapsed_s} is shorter than {horizon_s}s" + ) + state = flatten_state( + summarize_engine( + records, + start_ns=start_ns, + end_ns=start_ns + int(horizon_s * 1e9), + request_count=int(result["selection"]["count"]), + ) + ) + by_horizon[horizon_s].append( + { + "trial_id": str(result_path.relative_to(raw_root)), + "result_sha256": sha256_file(result_path), + "role": _trial_role(result_path), + "cell": str(result["cell"]), + "study_sha256": str(result["study_sha256"]), + "tp": int(result["tp"]), + "mns": int(result["mns"]), + "anchor": float(result["anchor"]), + "request_hash": str( + result["selection"]["request_id_order_sha256"] + ), + "request_count": int(result["selection"]["count"]), + "early_stopped": bool(result["early_stopped"]), + "full_pass_rate": float(result["pass_rate"]), + "full_feasible": bool(result["feasible"]), + "state": state, + } + ) + return by_horizon, stream_provenance + + +def _group_key(trial: Mapping[str, Any]) -> tuple[Any, ...]: + return ( + trial["study_sha256"], + trial["tp"], + trial["anchor"], + trial["request_hash"], + ) + + +def _delta(source: Mapping[str, Any], target: Mapping[str, Any]) -> dict[str, float]: + return { + feature: float(target["state"][feature]) - float(source["state"][feature]) + for feature in ALL_FEATURES + } + + +def _pair(source: Mapping[str, Any], target: Mapping[str, Any], kind: str) -> dict[str, Any]: + if _group_key(source) != _group_key(target): + raise ValueError("pair endpoints do not share workload identity") + return { + "kind": kind, + "group": { + "study_sha256": source["study_sha256"], + "tp": source["tp"], + "anchor": source["anchor"], + "request_hash": source["request_hash"], + }, + "source": { + "trial_id": source["trial_id"], + "cell": source["cell"], + "mns": source["mns"], + "early_stopped": source["early_stopped"], + "full_pass_rate": source["full_pass_rate"], + "full_feasible": source["full_feasible"], + }, + "target": { + "trial_id": target["trial_id"], + "cell": target["cell"], + "mns": target["mns"], + "early_stopped": target["early_stopped"], + "full_pass_rate": target["full_pass_rate"], + "full_feasible": target["full_feasible"], + }, + "delta_state": _delta(source, target), + "descriptive_full_outcome": { + "delta_pass_rate": target["full_pass_rate"] - source["full_pass_rate"], + "feasibility_transition": ( + f"{str(source['full_feasible']).lower()}->" + f"{str(target['full_feasible']).lower()}" + ), + }, + } + + +def build_pairs( + trials: list[dict[str, Any]], +) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: + primary_groups: dict[tuple[Any, ...], list[dict[str, Any]]] = defaultdict(list) + primary_by_cell_anchor: dict[tuple[Any, ...], dict[str, Any]] = {} + confirmations = [] + for trial in trials: + if trial["role"] == "primary": + primary_groups[_group_key(trial)].append(trial) + primary_by_cell_anchor[ + (trial["cell"], trial["anchor"], trial["request_hash"]) + ] = trial + else: + confirmations.append(trial) + + actions = [] + for group in primary_groups.values(): + ordered = sorted(group, key=lambda item: item["mns"]) + for source, target in zip(ordered, ordered[1:], strict=False): + if target["mns"] == source["mns"] * 2: + actions.append(_pair(source, target, "mns_increase")) + + repeats = [] + for confirmation in confirmations: + key = ( + confirmation["cell"], + confirmation["anchor"], + confirmation["request_hash"], + ) + primary = primary_by_cell_anchor.get(key) + if primary is None: + raise ValueError(f"{confirmation['trial_id']}: missing matched primary") + if primary["mns"] != confirmation["mns"]: + raise ValueError("repeat endpoints changed MNS") + repeats.append(_pair(primary, confirmation, "same_config_repeat")) + return actions, repeats + + +def response_statistics( + actions: list[dict[str, Any]], + repeats: list[dict[str, Any]], +) -> dict[str, Any]: + statistics = {} + for feature in ALL_FEATURES: + action = [float(pair["delta_state"][feature]) for pair in actions] + noise = [float(pair["delta_state"][feature]) for pair in repeats] + action_abs = [abs(value) for value in action] + noise_abs = [abs(value) for value in noise] + positive = sum(value > 1e-12 for value in action) + negative = sum(value < -1e-12 for value in action) + zero = len(action) - positive - negative + nonzero = positive + negative + sign_consistency = max(positive, negative) / nonzero if nonzero else 0.0 + action_median = median(action_abs) + noise_median = median(noise_abs) + noise_p95 = quantile(noise_abs, 0.95) + effect_to_noise = ( + action_median / noise_median + if noise_median > 0 + else (math.inf if action_median > 0 else 0.0) + ) + above_noise = sum(value > noise_p95 for value in action_abs) / len(action_abs) + qualifies = ( + feature in GATE_FEATURES + and sign_consistency >= MIN_SIGN_CONSISTENCY + and effect_to_noise >= MIN_EFFECT_TO_NOISE + and above_noise >= MIN_ABOVE_NOISE_P95_FRACTION + ) + statistics[feature] = { + "action_delta": numeric(action), + "repeat_delta": numeric(noise), + "action_abs_median": action_median, + "repeat_abs_median": noise_median, + "repeat_abs_p95": noise_p95, + "effect_to_repeat_median": ( + effect_to_noise if math.isfinite(effect_to_noise) else None + ), + "effect_to_repeat_median_is_infinite": math.isinf(effect_to_noise), + "action_signs": { + "positive": positive, + "negative": negative, + "zero": zero, + "consistency": sign_consistency, + }, + "action_above_repeat_p95_fraction": above_noise, + "gate_feature": feature in GATE_FEATURES, + "qualifies": qualifies, + } + return statistics + + +def analyze_horizon(trials: list[dict[str, Any]], horizon_s: float) -> dict[str, Any]: + actions, repeats = build_pairs(trials) + feature_statistics = response_statistics(actions, repeats) + qualifying = sorted( + feature for feature, item in feature_statistics.items() if item["qualifies"] + ) + all_values = [ + value + for trial in trials + for value in trial["state"].values() + ] + action_vectors = { + tuple(round(float(pair["delta_state"][feature]), 12) for feature in ALL_FEATURES) + for pair in actions + } + pair_invariants = { + "expected_action_pair_count": len(actions) == EXPECTED_ACTION_PAIRS, + "sufficient_repeat_pair_count": len(repeats) >= MIN_REPEAT_PAIRS, + "all_pair_hashes_match": all( + pair["group"]["request_hash"] for pair in [*actions, *repeats] + ), + "all_values_finite": all(math.isfinite(value) for value in all_values), + "state_vectors_not_all_identical": len(action_vectors) > 1, + "ratios_bounded": all( + 0.0 <= trial["state"][feature] <= 1.0 + for trial in trials + for feature in ( + "prefill_token_fraction", + "kv_usage_mean", + "kv_usage_max", + "graph_none_share", + "graph_full_share", + "graph_padding_fraction", + ) + ), + "nonnegative_counters": all( + trial["state"][feature] >= 0.0 + for trial in trials + for feature in ( + "scheduler_steps_per_s", + "batch_size.mean", + "batch_tokens.mean", + "decode_batch_size.mean", + "queue_waiting_mean", + "queue_running_mean", + "preemptions", + ) + ), + } + red_flags = [name for name, passed in pair_invariants.items() if not passed] + pass_deltas = [ + pair["descriptive_full_outcome"]["delta_pass_rate"] for pair in actions + ] + transitions = defaultdict(int) + for pair in actions: + transitions[pair["descriptive_full_outcome"]["feasibility_transition"]] += 1 + return { + "horizon_s": horizon_s, + "actions": actions, + "repeats": repeats, + "feature_statistics": feature_statistics, + "qualifying_features": qualifying, + "descriptive_full_outcome": { + "delta_pass_rate": numeric(pass_deltas), + "positive": sum(value > 1e-12 for value in pass_deltas), + "negative": sum(value < -1e-12 for value in pass_deltas), + "zero": sum(abs(value) <= 1e-12 for value in pass_deltas), + "feasibility_transitions": dict(sorted(transitions.items())), + "limitation": ( + "Full outcomes may use different elapsed durations when a trial " + "early-stopped; they are descriptive and are not a gate input." + ), + }, + "sanity": { + "trials": len(trials), + "action_pairs": len(actions), + "repeat_pairs": len(repeats), + "distinct_action_vectors": len(action_vectors), + "invariants": pair_invariants, + "red_flags": red_flags, + }, + } + + +def audit( + *, + metrics_path: Path, + raw_root: Path, + output_path: Path, +) -> dict[str, Any]: + trials_by_horizon, streams = load_trials(raw_root) + horizons = { + str(int(horizon)): analyze_horizon(trials, horizon) + for horizon, trials in sorted(trials_by_horizon.items()) + } + red_flags = sorted( + { + red_flag + for horizon in horizons.values() + for red_flag in horizon["sanity"]["red_flags"] + } + ) + stable_features = sorted( + set.intersection( + *(set(horizon["qualifying_features"]) for horizon in horizons.values()) + ) + ) + if red_flags: + decision = "STOP_DATA_INVALID" + elif len(stable_features) < MIN_STABLE_FEATURES: + decision = "STOP_NO_IDENTIFIABLE_RESPONSE" + else: + decision = "OPEN_MATCHED_PILOT" + payload = { + "schema": SCHEMA, + "status": "COMPLETE", + "decision": decision, + "claim_boundary": ( + "Development-only identifiability gate. Passing opens a controlled " + "real-GPU pilot; it does not establish tuning benefit or causality." + ), + "frozen_gate": { + "horizons_s": list(HORIZONS_S), + "expected_action_pairs": EXPECTED_ACTION_PAIRS, + "minimum_repeat_pairs": MIN_REPEAT_PAIRS, + "minimum_stable_features": MIN_STABLE_FEATURES, + "minimum_sign_consistency": MIN_SIGN_CONSISTENCY, + "minimum_effect_to_repeat_median": MIN_EFFECT_TO_NOISE, + "minimum_action_above_repeat_p95_fraction": ( + MIN_ABOVE_NOISE_P95_FRACTION + ), + "gate_features": list(GATE_FEATURES), + }, + "stable_qualifying_features": stable_features, + "horizons": horizons, + "provenance": { + "analysis_script": str(Path(__file__).resolve()), + "analysis_script_sha256": sha256_file(Path(__file__).resolve()), + "phase6_metrics": str(metrics_path.resolve()), + "phase6_metrics_sha256": sha256_file(metrics_path), + "raw_root": str(raw_root.resolve()), + "streams": streams, + }, + "sanity": { + "stream_count": len(streams), + "stream_bytes": numeric(item["bytes"] for item in streams), + "red_flags": red_flags, + }, + } + output_path.parent.mkdir(parents=True, exist_ok=True) + output_path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n") + return payload + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--metrics", type=Path, required=True) + parser.add_argument("--raw-root", type=Path, required=True) + parser.add_argument("--output", type=Path, required=True) + args = parser.parse_args() + payload = audit( + metrics_path=args.metrics, + raw_root=args.raw_root, + output_path=args.output, + ) + print( + json.dumps( + { + "decision": payload["decision"], + "stable_qualifying_features": payload[ + "stable_qualifying_features" + ], + "sanity": payload["sanity"], + }, + indent=2, + sort_keys=True, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/runs/intervention-response-v0/p1-audit.json b/runs/intervention-response-v0/p1-audit.json new file mode 100644 index 0000000..7164d08 --- /dev/null +++ b/runs/intervention-response-v0/p1-audit.json @@ -0,0 +1,6818 @@ +{ + "claim_boundary": "Development-only confirmation on an already-consumed P1 task. Passing can open a newly registered matched pilot but cannot be reported as held-out tuning evidence.", + "decision": "STOP_NO_PROSPECTIVE_RESPONSE", + "frozen_gate": { + "expected_action_pairs": 12, + "expected_repeat_pairs": 24, + "minimum_efficacy_balanced_accuracy": 0.75, + "minimum_efficacy_class": 4, + "minimum_efficacy_delta_over_best_outcome": 0.15, + "minimum_stable_response_features": 2, + "response_thresholds_identical_to_phase6_v0": true + }, + "horizons": { + "10": { + "actions": [ + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.0, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.0, + "tpot_max_over_slo": 0.04424092126093565, + "tpot_mean_over_slo": 0.008821253352839065, + "ttft_max_over_slo_max": 0.001164793997304514, + "ttft_mean_over_slo_max": -0.0007446444380963049 + }, + "delta_state": { + "batch_size.mean": 0.028437757317164802, + "batch_tokens.mean": -0.16003443371509718, + "decode_batch_size.mean": 0.02853132719514928, + "graph_full_share": -0.0012762931357137575, + "graph_none_share": -0.0069204281757616545, + "graph_padding_fraction": 0.006029111786335234, + "kv_usage_end_minus_start": 0.00036424504378218536, + "kv_usage_max": 0.009254174352690048, + "kv_usage_mean": 0.00277340001356393, + "preemptions": 0.0, + "prefill_token_fraction": -0.0003954091503666213, + "queue_running_mean": 0.21264213909999974, + "queue_waiting_mean": -0.073977916, + "scheduler_steps_per_s": 0.20000000000000284 + }, + "full_action_efficacy": 0, + "full_feasibility_transition": "false->false", + "group": { + "level": "high", + "offered_rate_per_gpu": 2.9833333333333334, + "replicate": 1, + "request_hash": "3f0ab9be34dbee884f5dbe2135b983d31a47578a43f606a5f390b0528dbedbe3", + "tp": 1 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.20670391061452514, + "mns": 8, + "requests_sha256": "5f5bfa4a16846190f488d3369eed89ae895804145cea59197e6b544b703223fc", + "result_sha256": "f65e3dc91d17f5caab1f4aecf97d2c464b99f107231af2cfd96f5484880136ee", + "trial_id": "cells/tp1_mns8/high-rep1/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.24581005586592178, + "mns": 64, + "requests_sha256": "e970dcac20144cb1e13a35997377f6695a9c57d788a88bad7f18cf6c64e35cec", + "result_sha256": "3233686b60b920dcd6cc2f45193a81f3af2d46f781ef42c4d117630612084feb", + "trial_id": "cells/tp1_mns64/high-rep1/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.032258064516129004, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.03225806451612906, + "tpot_max_over_slo": 0.33050636819556467, + "tpot_mean_over_slo": 0.2980276034718437, + "ttft_max_over_slo_max": -0.14499169250484553, + "ttft_mean_over_slo_max": -0.08870032973580096 + }, + "delta_state": { + "batch_size.mean": 4.5469521321594915, + "batch_tokens.mean": 177.93791776288268, + "decode_batch_size.mean": 4.490206104102559, + "graph_full_share": -0.049141465319289424, + "graph_none_share": 0.04533918395046808, + "graph_padding_fraction": 0.004209922294522723, + "kv_usage_end_minus_start": 0.05537535994708087, + "kv_usage_max": 0.08922043547542868, + "kv_usage_mean": 0.04639671324585863, + "preemptions": 0.0, + "prefill_token_fraction": 0.003967110353963799, + "queue_running_mean": 4.6810500217, + "queue_waiting_mean": -2.3262808059, + "scheduler_steps_per_s": -14.599999999999998 + }, + "full_action_efficacy": 0, + "full_feasibility_transition": "false->false", + "group": { + "level": "high", + "offered_rate_per_gpu": 2.9833333333333334, + "replicate": 2, + "request_hash": "b19c91876a8417fe06cb2775f65a1111b202f88ce10ec33576af3d84c059f02a", + "tp": 1 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.7988826815642458, + "mns": 8, + "requests_sha256": "e802d09057de349e5164c18314fcad09dc88c9673834fd6e5b100a57dd12fbf4", + "result_sha256": "4835a985dd6bb8dc50b53737baa980ac95a49e22f0b8a7326e1fb416c9b4e798", + "trial_id": "cells/tp1_mns8/high-rep2/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.88268156424581, + "mns": 64, + "requests_sha256": "ec06878e2aefdc4853d972197cedc29ab94df7147abb2701e0d88b5dabf29728", + "result_sha256": "8215477a014f061c55e94d879a25bbf1676ee2ef1c5e81efadd23d20d337e07a", + "trial_id": "cells/tp1_mns64/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.0, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.0, + "tpot_max_over_slo": 0.018804627718169264, + "tpot_mean_over_slo": 0.011575705913082518, + "ttft_max_over_slo_max": 0.0012841941691779934, + "ttft_mean_over_slo_max": -0.0028507176665395206 + }, + "delta_state": { + "batch_size.mean": 0.028484697519924218, + "batch_tokens.mean": 0.386581442994256, + "decode_batch_size.mean": 0.02831307423779572, + "graph_full_share": -0.00017162328212849687, + "graph_none_share": -0.003114247473621861, + "graph_padding_fraction": 0.003200143463807169, + "kv_usage_end_minus_start": 8.07298706054782e-05, + "kv_usage_max": 0.0034809583857736692, + "kv_usage_mean": 0.0010653256527363222, + "preemptions": 0.0, + "prefill_token_fraction": -0.00013286942159473902, + "queue_running_mean": 0.1416205103000001, + "queue_waiting_mean": -0.028138744, + "scheduler_steps_per_s": -0.6000000000000085 + }, + "full_action_efficacy": 0, + "full_feasibility_transition": "false->false", + "group": { + "level": "high", + "offered_rate_per_gpu": 2.9833333333333334, + "replicate": 3, + "request_hash": "a85849f1f057a67c82523cff57a52af22d2eb9514a953e076990aa6c25c1ef7e", + "tp": 1 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.6424581005586593, + "mns": 8, + "requests_sha256": "cf1226185845cd8aa4e7ead0cb5c95c77eda62b84851a2ab579f984bbb88e8ac", + "result_sha256": "95d5103f2678eeb99c258870324566932e2f2853c3b6e0ee94bc6c538f6ed865", + "trial_id": "cells/tp1_mns8/high-rep3/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.9273743016759777, + "mns": 64, + "requests_sha256": "18d72d1fe16136359e28a1909e395ffd553dbe3edd2c0fd93a9cc270a5ec6d60", + "result_sha256": "480a3b50acaf9b9c1902e2669cf3aa7723a6703a00778da269b5b9757990ceef", + "trial_id": "cells/tp1_mns64/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.0, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.0, + "tpot_max_over_slo": -0.0040397713397167245, + "tpot_mean_over_slo": -0.007906587129236364, + "ttft_max_over_slo_max": -0.00039426567188155515, + "ttft_mean_over_slo_max": -0.0011763758957386017 + }, + "delta_state": { + "batch_size.mean": -0.08160779537149798, + "batch_tokens.mean": -1.7609001853017006, + "decode_batch_size.mean": -0.08094394190416265, + "graph_full_share": 0.0006306607939687847, + "graph_none_share": -0.005369997286859742, + "graph_padding_fraction": 0.0002696603812660705, + "kv_usage_end_minus_start": 9.361443848254769e-05, + "kv_usage_max": 0.0003780815386457137, + "kv_usage_mean": 2.4214752986723154e-05, + "preemptions": 0.0, + "prefill_token_fraction": -6.638371684375421e-05, + "queue_running_mean": -0.0994468485000004, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 2.3000000000000114 + }, + "full_action_efficacy": 0, + "full_feasibility_transition": "true->true", + "group": { + "level": "low", + "offered_rate_per_gpu": 2.033333333333333, + "replicate": 1, + "request_hash": "c8ea9278f180ebb23cee595e167627cbed711032e70c9ca5ddc7205320cd75c0", + "tp": 1 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "requests_sha256": "0edc6095b16e5361a88b2765cc5d0f267ed16ff1d883e02fc3c58f57e59c1018", + "result_sha256": "8bc433109d148c21b7d158df95ec5d1fa4fa619243114563068e1e98c4241a29", + "trial_id": "cells/tp1_mns8/low-rep1/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "44d729c1ace9b09fe2ea4c4e110bd0f95fee69f83edc78ee0f65256922dcd2c2", + "result_sha256": "d2c08e71c5d4e0dd99662bab8457bd1ad0a4aba6bda57794dbfce62e36720f62", + "trial_id": "cells/tp1_mns64/low-rep1/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.0, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.0, + "tpot_max_over_slo": 0.08836641039618653, + "tpot_mean_over_slo": 0.05249869848340616, + "ttft_max_over_slo_max": -0.03703611367382109, + "ttft_mean_over_slo_max": -0.011082230367607901 + }, + "delta_state": { + "batch_size.mean": 0.2702547536010833, + "batch_tokens.mean": 7.3674632893748395, + "decode_batch_size.mean": 0.2679754243751127, + "graph_full_share": -0.000425589040939367, + "graph_none_share": -0.003064812355221179, + "graph_padding_fraction": 0.008784696835623326, + "kv_usage_end_minus_start": 2.2346672411965862e-05, + "kv_usage_max": 0.018441793350708946, + "kv_usage_mean": 0.009225433346662204, + "preemptions": 0.0, + "prefill_token_fraction": 2.292768411660262e-05, + "queue_running_mean": 0.7380613438000001, + "queue_waiting_mean": -0.2325565183, + "scheduler_steps_per_s": -3.8000000000000043 + }, + "full_action_efficacy": 0, + "full_feasibility_transition": "true->true", + "group": { + "level": "low", + "offered_rate_per_gpu": 2.033333333333333, + "replicate": 2, + "request_hash": "1f27fe31ca32fd67f2f70a54eee83146329a7838ff2a33be48ce4372640a858c", + "tp": 1 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "requests_sha256": "ca58a878401ac44cca0a9a595eab41659dafec2e923f7f2474e4f82ea30b2f3e", + "result_sha256": "42a56af136d1d3bdfc16d9cea092c2db0eaa4db2c85dceb21958c5e418122900", + "trial_id": "cells/tp1_mns8/low-rep2/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "97de3cced64fd88a5c2dcd087ca6c29d8b09a0a43d7bf0e4e844ef246462465b", + "result_sha256": "f194db2f7abb995171cd24626e4e515c000481f81283c929b9a5b63f110f1506", + "trial_id": "cells/tp1_mns64/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.0, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.0, + "tpot_max_over_slo": -0.0020900686586818318, + "tpot_mean_over_slo": -0.0010018654846283281, + "ttft_max_over_slo_max": 0.0005588701654535982, + "ttft_mean_over_slo_max": 6.347352852269228e-05 + }, + "delta_state": { + "batch_size.mean": -0.012547944623296114, + "batch_tokens.mean": -0.15241343405688212, + "decode_batch_size.mean": -0.012475695661875008, + "graph_full_share": 7.224896142110637e-05, + "graph_none_share": -0.0058946652641868255, + "graph_padding_fraction": 0.00029565151617282764, + "kv_usage_end_minus_start": 0.00011133071931368477, + "kv_usage_max": 0.0002683613903166071, + "kv_usage_mean": -1.5294343296619328e-05, + "preemptions": 0.0, + "prefill_token_fraction": 9.183515573107925e-05, + "queue_running_mean": -0.008641511400000024, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.20000000000000284 + }, + "full_action_efficacy": 0, + "full_feasibility_transition": "true->true", + "group": { + "level": "low", + "offered_rate_per_gpu": 2.033333333333333, + "replicate": 3, + "request_hash": "a46c62ebd8b7df5534831feb70aed45d23b1a5e7f8bf3d4cd82a79f182fbc69e", + "tp": 1 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "requests_sha256": "8a72240f84bbeff9eabd63e7d1f7a4c19910660fc5e4335013a1deaf89408127", + "result_sha256": "0214f32cabbcdc1bad6c331c3945c505cad136fcc9a8336aeb6314b27474e279", + "trial_id": "cells/tp1_mns8/low-rep3/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "30f4623100c58580cfa4efe9a1998c63581c8e44511c556ef39cf5bd777883bf", + "result_sha256": "0be457aa2fc9ce95bdb92a6eb25544f5f61a9739932ee5afa40535d26456e348", + "trial_id": "cells/tp1_mns64/low-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": -0.008, + "completed_over_admitted": -0.1610169491525424, + "completed_pass_rate": 0.08823529411764708, + "outstanding_over_admitted": 0.1610169491525424, + "tpot_max_over_slo": 0.29320454629189446, + "tpot_mean_over_slo": 0.2535434351882483, + "ttft_max_over_slo_max": -0.2690165124949999, + "ttft_mean_over_slo_max": -0.13813761862324808 + }, + "delta_state": { + "batch_size.mean": 10.093788314560394, + "batch_tokens.mean": 434.02936828958076, + "decode_batch_size.mean": 9.924284699384675, + "graph_full_share": -0.09005855324219958, + "graph_none_share": 0.07778357071650377, + "graph_padding_fraction": 0.0017247330951379231, + "kv_usage_end_minus_start": 0.05233364294717768, + "kv_usage_max": 0.049202174029810086, + "kv_usage_mean": 0.019156054903148284, + "preemptions": 0.0, + "prefill_token_fraction": 0.013365962658000052, + "queue_running_mean": 20.948292951200003, + "queue_waiting_mean": -13.1590807183, + "scheduler_steps_per_s": -34.5 + }, + "full_action_efficacy": 1, + "full_feasibility_transition": "false->true", + "group": { + "level": "high", + "offered_rate_per_gpu": 3.125, + "replicate": 1, + "request_hash": "5240182174ec5e25247be01c017cbefe2f1e59426bb24a57746dc40be4a82208", + "tp": 4 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.10666666666666667, + "mns": 16, + "requests_sha256": "8695422a0f1e0e1c097a08a7f4c082f1ba2e3bb26b58caadae0afc7438aeca90", + "result_sha256": "c54a2bb5c1b78bdef3fa09c39f5974215370d6fc7c2b6d403a3d376d53a1d9eb", + "trial_id": "cells/tp4_mns16/high-rep1/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "b4aeaf5b3175bd85fdac08a2ef657fb2278c6c4b36ea32ea417275ab6d55812d", + "result_sha256": "111a1042b614d05772888665a7cfbc86925b2fbeb52ffe19edb62a5bcfe2f513", + "trial_id": "cells/tp4_mns64/high-rep1/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": -0.012, + "completed_over_admitted": -0.1578947368421053, + "completed_pass_rate": 0.13636363636363635, + "outstanding_over_admitted": 0.1578947368421053, + "tpot_max_over_slo": 0.4737703299230537, + "tpot_mean_over_slo": 0.3241796650751651, + "ttft_max_over_slo_max": -0.3133456981643879, + "ttft_mean_over_slo_max": -0.1578698176905678 + }, + "delta_state": { + "batch_size.mean": 19.42960244648318, + "batch_tokens.mean": 656.7778499176663, + "decode_batch_size.mean": 19.184206069160197, + "graph_full_share": -0.13147494707127738, + "graph_none_share": 0.11760056457304163, + "graph_padding_fraction": 0.0010721073978083185, + "kv_usage_end_minus_start": 0.04855346265723404, + "kv_usage_max": 0.042070962023699754, + "kv_usage_mean": 0.022662705875080867, + "preemptions": 0.0, + "prefill_token_fraction": 0.007938598543200115, + "queue_running_mean": 24.0049637595, + "queue_waiting_mean": -15.5760687653, + "scheduler_steps_per_s": -32.900000000000006 + }, + "full_action_efficacy": 1, + "full_feasibility_transition": "false->true", + "group": { + "level": "high", + "offered_rate_per_gpu": 3.125, + "replicate": 2, + "request_hash": "51be592ba9a59c8d66eb1bcc70c3d2b011c87c66128aff36574973b40389ad96", + "tp": 4 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.092, + "mns": 16, + "requests_sha256": "aa0482b10414d911af227e2df172c19ecca0add2e0024dc88f85ffbd063854bb", + "result_sha256": "91e2491de4ca0868b667e7d126b755f03bdd78378681b8070a2bbc0c38fb9055", + "trial_id": "cells/tp4_mns16/high-rep2/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "5d82b6885f5c654ae1ae126696df4bafe04f5be1c1109db24c7856b0456d9443", + "result_sha256": "6ed574c18723e265ab1327c5e43d3c76d37b3fc5711d06c77a51718e4ba16601", + "trial_id": "cells/tp4_mns64/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.12844036697247707, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.12844036697247707, + "tpot_max_over_slo": 0.2467615478745419, + "tpot_mean_over_slo": 0.024430165887946775, + "ttft_max_over_slo_max": -0.08022667251255673, + "ttft_mean_over_slo_max": -0.04385035177332515 + }, + "delta_state": { + "batch_size.mean": 2.1439298581773514, + "batch_tokens.mean": 116.96904413675719, + "decode_batch_size.mean": 2.0885971125866956, + "graph_full_share": -0.028466450255056452, + "graph_none_share": 0.016098373855303175, + "graph_padding_fraction": 0.004743554546834421, + "kv_usage_end_minus_start": 0.0262231865121626, + "kv_usage_max": 0.020094834170883313, + "kv_usage_mean": 0.005378376045436206, + "preemptions": 0.0, + "prefill_token_fraction": 0.005752175072525123, + "queue_running_mean": 4.9523955869, + "queue_waiting_mean": -4.365988725199999, + "scheduler_steps_per_s": -10.100000000000009 + }, + "full_action_efficacy": 1, + "full_feasibility_transition": "false->true", + "group": { + "level": "high", + "offered_rate_per_gpu": 3.125, + "replicate": 3, + "request_hash": "604e338cf576d187157293922dada2bceb311567268ddae74eb7a089debf0242", + "tp": 4 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.14666666666666667, + "mns": 16, + "requests_sha256": "3a23ffbe0e724648226152ef5433cc5825ad640c37cf47997c2f091210eceeec", + "result_sha256": "136dde0451f806841ff3996b081fe0bffac0a76f60c3d78b7516f2689e106008", + "trial_id": "cells/tp4_mns16/high-rep3/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "5c5861d716181f06dc3f951ae0d6ee479b1b61fc21ebf24541c5b45053fcc167", + "result_sha256": "35b8f0465f6b0c197f71b5ecaf4e771e6613f86998ae44f8701ab9e4e1e440b4", + "trial_id": "cells/tp4_mns64/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.0, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.0, + "tpot_max_over_slo": 0.03209297007177109, + "tpot_mean_over_slo": -0.01184639150074901, + "ttft_max_over_slo_max": -0.04185720401195188, + "ttft_mean_over_slo_max": -0.005481651257700743 + }, + "delta_state": { + "batch_size.mean": -0.9669213868166988, + "batch_tokens.mean": -22.564692860834526, + "decode_batch_size.mean": -0.9550554240524107, + "graph_full_share": 0.009900102186990445, + "graph_none_share": -0.015869663207727508, + "graph_padding_fraction": -0.0007445684074620391, + "kv_usage_end_minus_start": 5.549832249451825e-05, + "kv_usage_max": 0.004800695185764425, + "kv_usage_mean": -0.0003621004636635179, + "preemptions": 0.0, + "prefill_token_fraction": -0.00013559912520566542, + "queue_running_mean": -0.46276202019999957, + "queue_waiting_mean": -0.0902122614, + "scheduler_steps_per_s": 11.900000000000006 + }, + "full_action_efficacy": 1, + "full_feasibility_transition": "false->true", + "group": { + "level": "low", + "offered_rate_per_gpu": 2.125, + "replicate": 1, + "request_hash": "6fb170f366b68a4e4e0fc976d370cb1f5b7b915d4dc22ebe5db3c6b9615afe68", + "tp": 4 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.6196078431372549, + "mns": 16, + "requests_sha256": "d7eaaefd35cc906f759dcaa7ac3c8543249a1a02f28572bec953e41e4379a29f", + "result_sha256": "11d9ec9d2a3358aed988f7b4b1014af087d61c4b5a72eb9076ae19bb5cc481cd", + "trial_id": "cells/tp4_mns16/low-rep1/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "931d372ded1e3aaa9c67f06653fac8f79b4ee4f369028c1148163580386681ce", + "result_sha256": "325ce57f33133670a6761b5dffb831ed3b2f464755ff743b56976b4a974c1215", + "trial_id": "cells/tp4_mns64/low-rep1/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.05128205128205132, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.051282051282051294, + "tpot_max_over_slo": 0.03807669731890995, + "tpot_mean_over_slo": -0.014506958738293885, + "ttft_max_over_slo_max": -0.12963614600206105, + "ttft_mean_over_slo_max": -0.048670619592321884 + }, + "delta_state": { + "batch_size.mean": -1.4718645603306726, + "batch_tokens.mean": -31.86018426395526, + "decode_batch_size.mean": -1.4608669627184998, + "graph_full_share": 0.02356281394840931, + "graph_none_share": -0.027804605789997328, + "graph_padding_fraction": 0.0035831460549140947, + "kv_usage_end_minus_start": -0.002621229743826836, + "kv_usage_max": 0.0030741209471074615, + "kv_usage_mean": -8.774771567193577e-05, + "preemptions": 0.0, + "prefill_token_fraction": 0.0001064077287293852, + "queue_running_mean": -0.40493394709999997, + "queue_waiting_mean": -2.0223754996, + "scheduler_steps_per_s": 10.599999999999994 + }, + "full_action_efficacy": 1, + "full_feasibility_transition": "false->true", + "group": { + "level": "low", + "offered_rate_per_gpu": 2.125, + "replicate": 2, + "request_hash": "eb4c0445556d23d73d27d728b45e63fec44e17e84a4f2f341787108b7f7a4901", + "tp": 4 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.6803921568627451, + "mns": 16, + "requests_sha256": "7fdb90f679bba1747fbacc92fac2045c820e09965c755b20f6dafd4fd9e26a7a", + "result_sha256": "800e2aa6e9f9efef4be12ee778be6817364914d63ae0624775d02729089768d6", + "trial_id": "cells/tp4_mns16/low-rep2/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "72c8f70a240f79edcaa4eb0a2fe9bade8ac07093339c5b2d09c49ddd1cf27d16", + "result_sha256": "ff8b2283d02d5967893ca6225b561ae11011da6149d1f6cff7b4275c00170e1d", + "trial_id": "cells/tp4_mns64/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.0, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.0, + "tpot_max_over_slo": 0.04088999417529798, + "tpot_mean_over_slo": -0.0032529423795618906, + "ttft_max_over_slo_max": 0.0002604483355147097, + "ttft_mean_over_slo_max": -0.001620827191598239 + }, + "delta_state": { + "batch_size.mean": 0.14852247907791494, + "batch_tokens.mean": 11.553519812007579, + "decode_batch_size.mean": 0.14728805801238387, + "graph_full_share": 0.0005649503708670123, + "graph_none_share": -0.0023940560373101466, + "graph_padding_fraction": -0.00035714669425012356, + "kv_usage_end_minus_start": 0.0014602804352583654, + "kv_usage_max": 0.003991863602817669, + "kv_usage_mean": 4.656051020407101e-06, + "preemptions": 0.0, + "prefill_token_fraction": 0.0018350834191880327, + "queue_running_mean": 0.06592412640000056, + "queue_waiting_mean": -0.2173940436, + "scheduler_steps_per_s": 1.1000000000000085 + }, + "full_action_efficacy": 1, + "full_feasibility_transition": "false->true", + "group": { + "level": "low", + "offered_rate_per_gpu": 2.125, + "replicate": 3, + "request_hash": "a660c44d1f8b9c0ada5a19285fa579871bcfcae7c6fa71649546efda9aa3baef", + "tp": 4 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.6294117647058823, + "mns": 16, + "requests_sha256": "b592fe254476957265fc9139aefdea77be4b5540f3c1b8a429c10ea6ccab9a6a", + "result_sha256": "cc1b1f7f5280c2892d0c6deac9df9f34ce126b0284e6ad893ffbf0ddbf27969f", + "trial_id": "cells/tp4_mns16/low-rep3/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "8b2c779d2097c5e4038e94e1ac9b986e29f55d9acfd67eeb366c4e0e9270f6e0", + "result_sha256": "f026b69356701894fab184e0f2f7504a30b537982e823373899c9ab123a33891", + "trial_id": "cells/tp4_mns64/low-rep3/result.json" + } + } + ], + "efficacy": { + "feasibility_transitions": { + "false->false": 3, + "false->true": 6, + "true->true": 3 + }, + "minimum_balanced_accuracy": 0.75, + "minimum_delta_over_best_outcome": 0.15, + "outcome_delta": { + "best_accuracy": 0.75, + "best_balanced_accuracy": 0.75, + "best_feature": "outstanding_over_admitted", + "features": { + "admitted_fraction": { + "accuracy": 0.5, + "balanced_accuracy": 0.5, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + } + ] + }, + "admitted_input_tokens_mean_over_limit": { + "accuracy": 0.5, + "balanced_accuracy": 0.5, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + } + ] + }, + "completed_fail_fraction_of_total": { + "accuracy": 0.6666666666666666, + "balanced_accuracy": 0.6666666666666666, + "folds": [ + { + "direction": -1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": -0.006, + "train_balanced_accuracy": 0.625 + }, + { + "direction": -1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": -0.004, + "train_balanced_accuracy": 0.625 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": -0.004, + "train_balanced_accuracy": 0.75 + } + ] + }, + "completed_over_admitted": { + "accuracy": 0.75, + "balanced_accuracy": 0.75, + "folds": [ + { + "direction": -1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": -0.08034921574430304, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": -0.06422018348623854, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": -0.09507640067911716, + "train_balanced_accuracy": 0.75 + } + ] + }, + "completed_pass_rate": { + "accuracy": 0.6666666666666666, + "balanced_accuracy": 0.6666666666666666, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": 0.06818181818181818, + "train_balanced_accuracy": 0.625 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": 0.04411764705882354, + "train_balanced_accuracy": 0.625 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": 0.04411764705882354, + "train_balanced_accuracy": 0.75 + } + ] + }, + "outstanding_over_admitted": { + "accuracy": 0.75, + "balanced_accuracy": 0.75, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": 0.08034921574430307, + "train_balanced_accuracy": 0.75 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": 0.06422018348623854, + "train_balanced_accuracy": 0.75 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": 0.09507640067911718, + "train_balanced_accuracy": 0.75 + } + ] + }, + "tpot_max_over_slo": { + "accuracy": 0.6666666666666666, + "balanced_accuracy": 0.6666666666666666, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 0, + 1, + 1 + ], + "threshold": 0.028440662518539606, + "train_balanced_accuracy": 0.75 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.025448798894970176, + "train_balanced_accuracy": 0.875 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 0, + 1, + 1 + ], + "threshold": 0.014026599366027181, + "train_balanced_accuracy": 0.625 + } + ] + }, + "tpot_mean_over_slo": { + "accuracy": 0.4166666666666667, + "balanced_accuracy": 0.41666666666666663, + "folds": [ + { + "direction": -1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 1, + 0, + 1 + ], + "threshold": -0.0021274039320951094, + "train_balanced_accuracy": 0.75 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 0 + ], + "threshold": 0.018002935900514647, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": -0.009876489314992687, + "train_balanced_accuracy": 0.75 + } + ] + }, + "ttft_max_over_slo_max": { + "accuracy": 0.6666666666666666, + "balanced_accuracy": 0.6666666666666667, + "folds": [ + { + "direction": -1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 1, + 1, + 1 + ], + "threshold": 0.00040965925048415397, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.00040965925048415397, + "train_balanced_accuracy": 0.875 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": -0.039446658842886485, + "train_balanced_accuracy": 0.875 + } + ] + }, + "ttft_mean_over_slo_max": { + "accuracy": 0.6666666666666666, + "balanced_accuracy": 0.6666666666666666, + "folds": [ + { + "direction": -1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": -0.027466291070466525, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": -0.0013986015436684204, + "train_balanced_accuracy": 0.875 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": -0.0033290135767196725, + "train_balanced_accuracy": 0.75 + } + ] + } + }, + "labels": { + "distinct_n": 2, + "max": 1.0, + "min": 0.0, + "n": 12 + }, + "negative": 6, + "positive": 6 + }, + "telemetry_delta": { + "best_accuracy": 0.75, + "best_balanced_accuracy": 0.75, + "best_feature": "queue_waiting_mean", + "features": { + "decode_batch_size.mean": { + "accuracy": 0.5, + "balanced_accuracy": 0.5, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": 0.0878005661250898, + "train_balanced_accuracy": 0.625 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 0 + ], + "threshold": 0.08790969260376658, + "train_balanced_accuracy": 0.875 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": -0.5179996829782867, + "train_balanced_accuracy": 0.75 + } + ] + }, + "graph_padding_fraction": { + "accuracy": 0.5, + "balanced_accuracy": 0.5, + "folds": [ + { + "direction": -1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 1 + ], + "threshold": -3.074758903864796e-05, + "train_balanced_accuracy": 0.625 + }, + { + "direction": -1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": -4.3743156492026536e-05, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 0, + 1 + ], + "threshold": 0.0038965341747184087, + "train_balanced_accuracy": 0.875 + } + ] + }, + "kv_usage_mean": { + "accuracy": 0.5, + "balanced_accuracy": 0.5, + "folds": [ + { + "direction": -1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 1 + ], + "threshold": -5.152102948427755e-05, + "train_balanced_accuracy": 0.625 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 0 + ], + "threshold": 0.004075888029500068, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": -3.176648134260631e-05, + "train_balanced_accuracy": 0.75 + } + ] + }, + "prefill_token_fraction": { + "accuracy": 0.6666666666666666, + "balanced_accuracy": 0.6666666666666666, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": 9.912144223023223e-05, + "train_balanced_accuracy": 0.875 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 0, + 1, + 0 + ], + "threshold": 0.000963459287459556, + "train_balanced_accuracy": 0.875 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 1, + 1, + 1 + ], + "threshold": 6.466770642299391e-05, + "train_balanced_accuracy": 0.75 + } + ] + }, + "queue_running_mean": { + "accuracy": 0.5833333333333334, + "balanced_accuracy": 0.5833333333333334, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": 4.816722804299999, + "train_balanced_accuracy": 0.75 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 0, + 1, + 0 + ], + "threshold": 2.5825188629999998, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": -0.2521903978000002, + "train_balanced_accuracy": 0.75 + } + ] + }, + "queue_waiting_mean": { + "accuracy": 0.75, + "balanced_accuracy": 0.75, + "folds": [ + { + "direction": -1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": -0.1227663938, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": -0.0820950887, + "train_balanced_accuracy": 1.0 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 1 + ], + "threshold": -0.0820950887, + "train_balanced_accuracy": 0.75 + } + ] + }, + "scheduler_steps_per_s": { + "accuracy": 0.5, + "balanced_accuracy": 0.5, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 1, + 0, + 1 + ], + "threshold": 0.6500000000000057, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 0, + 1, + 0 + ], + "threshold": -5.3500000000000085, + "train_balanced_accuracy": 0.75 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": 6.450000000000003, + "train_balanced_accuracy": 0.75 + } + ] + } + }, + "labels": { + "distinct_n": 2, + "max": 1.0, + "min": 0.0, + "n": 12 + }, + "negative": 6, + "positive": 6 + }, + "telemetry_qualifying_features": [] + }, + "horizon_s": 10.0, + "qualifying_response_features": [], + "repeats": [ + { + "delta_outcome": { + "admitted_fraction": 0.027932960893854747, + "admitted_input_tokens_mean_over_limit": 0.06722636258335918, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.21464019851116622, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.21464019851116628, + "tpot_max_over_slo": 0.3907463973292743, + "tpot_mean_over_slo": 0.45304077139972754, + "ttft_max_over_slo_max": -0.026048107499567152, + "ttft_mean_over_slo_max": 0.02040584175783646 + }, + "delta_state": { + "batch_size.mean": 8.048982941677576, + "batch_tokens.mean": 298.1121465228864, + "decode_batch_size.mean": 7.965265224708595, + "graph_full_share": -0.07611315423133669, + "graph_none_share": 0.08050759417399073, + "graph_padding_fraction": -0.006831997792023563, + "kv_usage_end_minus_start": 0.08232590668398432, + "kv_usage_max": 0.11409731241882304, + "kv_usage_mean": 0.08571139047521727, + "preemptions": 0.0, + "prefill_token_fraction": 0.010675483227336025, + "queue_running_mean": 7.2005321570000005, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -46.900000000000006 + }, + "group": { + "cell": "tp1_mns64", + "level": "high", + "mns": 64, + "source_replicate": 1, + "target_replicate": 2, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "e970dcac20144cb1e13a35997377f6695a9c57d788a88bad7f18cf6c64e35cec", + "result_sha256": "3233686b60b920dcd6cc2f45193a81f3af2d46f781ef42c4d117630612084feb", + "trial_id": "cells/tp1_mns64/high-rep1/result.json" + }, + "target": { + "requests_sha256": "ec06878e2aefdc4853d972197cedc29ab94df7147abb2701e0d88b5dabf29728", + "result_sha256": "8215477a014f061c55e94d879a25bbf1676ee2ef1c5e81efadd23d20d337e07a", + "trial_id": "cells/tp1_mns64/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.03910614525139666, + "admitted_input_tokens_mean_over_limit": -0.15364353631132394, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.31720430107526887, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.31720430107526887, + "tpot_max_over_slo": -0.4318866070898938, + "tpot_mean_over_slo": -0.4648576303649653, + "ttft_max_over_slo_max": -0.0451326228309578, + "ttft_mean_over_slo_max": -0.03512127695333522 + }, + "delta_state": { + "batch_size.mean": -8.639628684110797, + "batch_tokens.mean": -331.31332381027744, + "decode_batch_size.mean": -8.548044927723337, + "graph_full_share": 0.08397919364981532, + "graph_none_share": -0.08346278303674427, + "graph_padding_fraction": 0.0049766447911436746, + "kv_usage_end_minus_start": -0.12798481366769898, + "kv_usage_max": -0.12688580277750028, + "kv_usage_mean": -0.09580544440945148, + "preemptions": 0.0, + "prefill_token_fraction": -0.024511024899494305, + "queue_running_mean": -7.6525189056, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 65.0 + }, + "group": { + "cell": "tp1_mns64", + "level": "high", + "mns": 64, + "source_replicate": 2, + "target_replicate": 3, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "ec06878e2aefdc4853d972197cedc29ab94df7147abb2701e0d88b5dabf29728", + "result_sha256": "8215477a014f061c55e94d879a25bbf1676ee2ef1c5e81efadd23d20d337e07a", + "trial_id": "cells/tp1_mns64/high-rep2/result.json" + }, + "target": { + "requests_sha256": "18d72d1fe16136359e28a1909e395ffd553dbe3edd2c0fd93a9cc270a5ec6d60", + "result_sha256": "480a3b50acaf9b9c1902e2669cf3aa7723a6703a00778da269b5b9757990ceef", + "trial_id": "cells/tp1_mns64/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.008196721311475419, + "admitted_input_tokens_mean_over_limit": 0.07372581845238091, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.09285714285714286, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.09285714285714285, + "tpot_max_over_slo": 0.1702932155907418, + "tpot_mean_over_slo": 0.1739500633542023, + "ttft_max_over_slo_max": 0.02082575849878293, + "ttft_mean_over_slo_max": 0.029532855802237655 + }, + "delta_state": { + "batch_size.mean": 1.3717277486910993, + "batch_tokens.mean": 56.51418492510525, + "decode_batch_size.mean": 1.3587752164958689, + "graph_full_share": -0.010646964922293112, + "graph_none_share": 0.011895900019023516, + "graph_padding_fraction": 0.0086692890425959, + "kv_usage_end_minus_start": -0.017684084324108285, + "kv_usage_max": 0.05015486062543706, + "kv_usage_mean": 0.03571575463439401, + "preemptions": 0.0, + "prefill_token_fraction": 0.011636868678620127, + "queue_running_mean": 2.2687814585000003, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -27.10000000000001 + }, + "group": { + "cell": "tp1_mns64", + "level": "low", + "mns": 64, + "source_replicate": 1, + "target_replicate": 2, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "44d729c1ace9b09fe2ea4c4e110bd0f95fee69f83edc78ee0f65256922dcd2c2", + "result_sha256": "d2c08e71c5d4e0dd99662bab8457bd1ad0a4aba6bda57794dbfce62e36720f62", + "trial_id": "cells/tp1_mns64/low-rep1/result.json" + }, + "target": { + "requests_sha256": "97de3cced64fd88a5c2dcd087ca6c29d8b09a0a43d7bf0e4e844ef246462465b", + "result_sha256": "f194db2f7abb995171cd24626e4e515c000481f81283c929b9a5b63f110f1506", + "trial_id": "cells/tp1_mns64/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.02459016393442623, + "admitted_input_tokens_mean_over_limit": -0.09311379825367644, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.24411764705882344, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.24411764705882355, + "tpot_max_over_slo": -0.3084416280309926, + "tpot_mean_over_slo": -0.21178917402407615, + "ttft_max_over_slo_max": -0.07642558032724386, + "ttft_mean_over_slo_max": -0.031511784150528625 + }, + "delta_state": { + "batch_size.mean": -1.5740567152122056, + "batch_tokens.mean": -51.36471646204379, + "decode_batch_size.mean": -1.5621527698392743, + "graph_full_share": 0.008413543976771298, + "graph_none_share": -0.010745558883376392, + "graph_padding_fraction": -0.007424342975302652, + "kv_usage_end_minus_start": 0.022080127884903655, + "kv_usage_max": -0.0773803576780897, + "kv_usage_mean": -0.04564071465536516, + "preemptions": 0.0, + "prefill_token_fraction": -0.004854783915929306, + "queue_running_mean": -3.3275810848000003, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 11.400000000000006 + }, + "group": { + "cell": "tp1_mns64", + "level": "low", + "mns": 64, + "source_replicate": 2, + "target_replicate": 3, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "97de3cced64fd88a5c2dcd087ca6c29d8b09a0a43d7bf0e4e844ef246462465b", + "result_sha256": "f194db2f7abb995171cd24626e4e515c000481f81283c929b9a5b63f110f1506", + "trial_id": "cells/tp1_mns64/low-rep2/result.json" + }, + "target": { + "requests_sha256": "30f4623100c58580cfa4efe9a1998c63581c8e44511c556ef39cf5bd777883bf", + "result_sha256": "0be457aa2fc9ce95bdb92a6eb25544f5f61a9739932ee5afa40535d26456e348", + "trial_id": "cells/tp1_mns64/low-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.027932960893854747, + "admitted_input_tokens_mean_over_limit": 0.06722636258335918, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.18238213399503722, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.18238213399503722, + "tpot_max_over_slo": 0.10448095039464528, + "tpot_mean_over_slo": 0.1638344212807229, + "ttft_max_over_slo_max": 0.1201083790025829, + "ttft_mean_over_slo_max": 0.10836152705554111 + }, + "delta_state": { + "batch_size.mean": 3.5304685668352485, + "batch_tokens.mean": 120.01419432628865, + "decode_batch_size.mean": 3.503590447801186, + "graph_full_share": -0.028247982047761022, + "graph_none_share": 0.028247982047760994, + "graph_padding_fraction": -0.005012808300211052, + "kv_usage_end_minus_start": 0.027314791780685632, + "kv_usage_max": 0.0341310512960844, + "kv_usage_mean": 0.042088077242922566, + "preemptions": 0.0, + "prefill_token_fraction": 0.006312963723005605, + "queue_running_mean": 2.7321242744000003, + "queue_waiting_mean": 2.2523028899, + "scheduler_steps_per_s": -32.1 + }, + "group": { + "cell": "tp1_mns8", + "level": "high", + "mns": 8, + "source_replicate": 1, + "target_replicate": 2, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "5f5bfa4a16846190f488d3369eed89ae895804145cea59197e6b544b703223fc", + "result_sha256": "f65e3dc91d17f5caab1f4aecf97d2c464b99f107231af2cfd96f5484880136ee", + "trial_id": "cells/tp1_mns8/high-rep1/result.json" + }, + "target": { + "requests_sha256": "e802d09057de349e5164c18314fcad09dc88c9673834fd6e5b100a57dd12fbf4", + "result_sha256": "4835a985dd6bb8dc50b53737baa980ac95a49e22f0b8a7326e1fb416c9b4e798", + "trial_id": "cells/tp1_mns8/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.03910614525139666, + "admitted_input_tokens_mean_over_limit": -0.15364353631132394, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.28494623655913986, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.28494623655913975, + "tpot_max_over_slo": -0.12018486661249839, + "tpot_mean_over_slo": -0.17840573280620411, + "ttft_max_over_slo_max": -0.19140850950498134, + "ttft_mean_over_slo_max": -0.12097088902259666 + }, + "delta_state": { + "batch_size.mean": -4.121161249471228, + "batch_tokens.mean": -153.761987490389, + "decode_batch_size.mean": -4.086151897858574, + "graph_full_share": 0.035009351612654394, + "graph_none_share": -0.03500935161265434, + "graph_padding_fraction": 0.0059864236218592284, + "kv_usage_end_minus_start": -0.07269018359122359, + "kv_usage_max": -0.041146325687845264, + "kv_usage_mean": -0.050474056816329174, + "preemptions": 0.0, + "prefill_token_fraction": -0.020411045123935767, + "queue_running_mean": -3.1130893942, + "queue_waiting_mean": -2.2981420619, + "scheduler_steps_per_s": 51.00000000000001 + }, + "group": { + "cell": "tp1_mns8", + "level": "high", + "mns": 8, + "source_replicate": 2, + "target_replicate": 3, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "e802d09057de349e5164c18314fcad09dc88c9673834fd6e5b100a57dd12fbf4", + "result_sha256": "4835a985dd6bb8dc50b53737baa980ac95a49e22f0b8a7326e1fb416c9b4e798", + "trial_id": "cells/tp1_mns8/high-rep2/result.json" + }, + "target": { + "requests_sha256": "cf1226185845cd8aa4e7ead0cb5c95c77eda62b84851a2ab579f984bbb88e8ac", + "result_sha256": "95d5103f2678eeb99c258870324566932e2f2853c3b6e0ee94bc6c538f6ed865", + "trial_id": "cells/tp1_mns8/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.008196721311475419, + "admitted_input_tokens_mean_over_limit": 0.07372581845238091, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.09285714285714286, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.09285714285714285, + "tpot_max_over_slo": 0.07788703385483853, + "tpot_mean_over_slo": 0.11354477774155977, + "ttft_max_over_slo_max": 0.05746760650072247, + "ttft_mean_over_slo_max": 0.039438710274106954 + }, + "delta_state": { + "batch_size.mean": 1.019865199718518, + "batch_tokens.mean": 47.38582145042871, + "decode_batch_size.mean": 1.0098558502165935, + "graph_full_share": -0.00959071508738496, + "graph_none_share": 0.009590715087384953, + "graph_padding_fraction": 0.00015425258823864325, + "kv_usage_end_minus_start": -0.017612816558037703, + "kv_usage_max": 0.032091148813373827, + "kv_usage_mean": 0.02651453604071853, + "preemptions": 0.0, + "prefill_token_fraction": 0.01154755727765977, + "queue_running_mean": 1.4312732661999998, + "queue_waiting_mean": 0.2325565183, + "scheduler_steps_per_s": -20.999999999999993 + }, + "group": { + "cell": "tp1_mns8", + "level": "low", + "mns": 8, + "source_replicate": 1, + "target_replicate": 2, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "0edc6095b16e5361a88b2765cc5d0f267ed16ff1d883e02fc3c58f57e59c1018", + "result_sha256": "8bc433109d148c21b7d158df95ec5d1fa4fa619243114563068e1e98c4241a29", + "trial_id": "cells/tp1_mns8/low-rep1/result.json" + }, + "target": { + "requests_sha256": "ca58a878401ac44cca0a9a595eab41659dafec2e923f7f2474e4f82ea30b2f3e", + "result_sha256": "42a56af136d1d3bdfc16d9cea092c2db0eaa4db2c85dceb21958c5e418122900", + "trial_id": "cells/tp1_mns8/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.02459016393442623, + "admitted_input_tokens_mean_over_limit": -0.09311379825367644, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.24411764705882344, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.24411764705882355, + "tpot_max_over_slo": -0.21798514897612425, + "tpot_mean_over_slo": -0.15828861005604167, + "ttft_max_over_slo_max": -0.11402056416651855, + "ttft_mean_over_slo_max": -0.04265748804665922 + }, + "delta_state": { + "batch_size.mean": -1.2912540169878262, + "batch_tokens.mean": -43.844839738612066, + "decode_batch_size.mean": -1.2817016498022866, + "graph_full_share": 0.007915705974410825, + "graph_none_share": -0.007915705974410745, + "graph_padding_fraction": 0.0010647023441478472, + "kv_usage_end_minus_start": 0.021991143838001936, + "kv_usage_max": -0.05920692571769737, + "kv_usage_mean": -0.036399986965406333, + "preemptions": 0.0, + "prefill_token_fraction": -0.004923691387543783, + "queue_running_mean": -2.5808782296, + "queue_waiting_mean": -0.2325565183, + "scheduler_steps_per_s": 7.399999999999999 + }, + "group": { + "cell": "tp1_mns8", + "level": "low", + "mns": 8, + "source_replicate": 2, + "target_replicate": 3, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "ca58a878401ac44cca0a9a595eab41659dafec2e923f7f2474e4f82ea30b2f3e", + "result_sha256": "42a56af136d1d3bdfc16d9cea092c2db0eaa4db2c85dceb21958c5e418122900", + "trial_id": "cells/tp1_mns8/low-rep2/result.json" + }, + "target": { + "requests_sha256": "8a72240f84bbeff9eabd63e7d1f7a4c19910660fc5e4335013a1deaf89408127", + "result_sha256": "0214f32cabbcdc1bad6c331c3945c505cad136fcc9a8336aeb6314b27474e279", + "trial_id": "cells/tp1_mns8/low-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.014492753623188387, + "admitted_input_tokens_mean_over_limit": 0.04833232120973391, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.008403361344537785, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.00840336134453784, + "tpot_max_over_slo": 0.09841551118728337, + "tpot_mean_over_slo": 0.06345367037672023, + "ttft_max_over_slo_max": 0.010166719497647136, + "ttft_mean_over_slo_max": 0.006259302157370798 + }, + "delta_state": { + "batch_size.mean": 2.0365641486137616, + "batch_tokens.mean": 91.46332360534291, + "decode_batch_size.mean": 2.012753956673029, + "graph_full_share": -0.01772084409024577, + "graph_none_share": 0.021565271074194634, + "graph_padding_fraction": -0.002786564210742205, + "kv_usage_end_minus_start": 0.007622555602450509, + "kv_usage_max": 0.020987606952384663, + "kv_usage_mean": 0.007630049119681775, + "preemptions": 0.0, + "prefill_token_fraction": 0.005242973565105835, + "queue_running_mean": 0.8145702931999992, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -13.199999999999996 + }, + "group": { + "cell": "tp2_mns64", + "level": "high", + "mns": 64, + "source_replicate": 1, + "target_replicate": 2, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "19537ec05f1e40543d850964db12234561954c209d55cd8cd0a1da716ab105fc", + "result_sha256": "49523b3269db649aa70072058666da3309ecabb93242cd504b6413f5de0f5d54", + "trial_id": "cells/tp2_mns64/high-rep1/result.json" + }, + "target": { + "requests_sha256": "d95e0dcc3d3f25af11b4d3da0ca133f647fd602753b804337a7131cc56e03059", + "result_sha256": "f37a42d9ea734adcb24892f86cbb19e2c51cee0baf8a6a63c5d51c4820bd28f2", + "trial_id": "cells/tp2_mns64/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.005797101449275366, + "admitted_input_tokens_mean_over_limit": -0.08122977688274602, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.10543840177580466, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.10543840177580466, + "tpot_max_over_slo": -0.08790813528521968, + "tpot_mean_over_slo": -0.0976607763237542, + "ttft_max_over_slo_max": -0.031135886325500906, + "ttft_mean_over_slo_max": -0.007596982260572371 + }, + "delta_state": { + "batch_size.mean": -2.9554801420404466, + "batch_tokens.mean": -131.8397196967789, + "decode_batch_size.mean": -2.9177065756667595, + "graph_full_share": 0.026547586067947715, + "graph_none_share": -0.024236910368448883, + "graph_padding_fraction": 0.005457793019402147, + "kv_usage_end_minus_start": -0.01758559388149228, + "kv_usage_max": -0.016281062553556214, + "kv_usage_mean": -0.00956401468061617, + "preemptions": 0.0, + "prefill_token_fraction": -0.00900387036264405, + "queue_running_mean": -2.3104728836999993, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 20.099999999999994 + }, + "group": { + "cell": "tp2_mns64", + "level": "high", + "mns": 64, + "source_replicate": 2, + "target_replicate": 3, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "d95e0dcc3d3f25af11b4d3da0ca133f647fd602753b804337a7131cc56e03059", + "result_sha256": "f37a42d9ea734adcb24892f86cbb19e2c51cee0baf8a6a63c5d51c4820bd28f2", + "trial_id": "cells/tp2_mns64/high-rep2/result.json" + }, + "target": { + "requests_sha256": "ccba3d0a18a7db8501b040855bda473ee55c519619d4b9fa2a105bda06300829", + "result_sha256": "55447419925f30397d19863e149890241c58863d0adaafd511a67757905cb58e", + "trial_id": "cells/tp2_mns64/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.004255319148936149, + "admitted_input_tokens_mean_over_limit": 0.027061719804318485, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.002024291497975783, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.0020242914979757, + "tpot_max_over_slo": 0.09163424472588544, + "tpot_mean_over_slo": 0.0001830762350235604, + "ttft_max_over_slo_max": 0.0006185861614843163, + "ttft_mean_over_slo_max": 0.0017585336856889636 + }, + "delta_state": { + "batch_size.mean": -0.4199832128448815, + "batch_tokens.mean": 6.494131535483177, + "decode_batch_size.mean": -0.4188308558741509, + "graph_full_share": 0.0010917066038501622, + "graph_none_share": 0.00011588552243251699, + "graph_padding_fraction": -0.0006875875614091621, + "kv_usage_end_minus_start": 0.009093350727084282, + "kv_usage_max": 0.011843098134008634, + "kv_usage_mean": 0.0004732259215823806, + "preemptions": 0.0, + "prefill_token_fraction": 0.005759524366025781, + "queue_running_mean": -0.24529797560000066, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 2.799999999999997 + }, + "group": { + "cell": "tp2_mns64", + "level": "low", + "mns": 64, + "source_replicate": 1, + "target_replicate": 2, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "8685f475baf247f7ce52a6a2df1183cd77a6f580cd57a3a87c407b4e96c0895f", + "result_sha256": "7a8f4e462d496bd56b73b0a686653cbe499a238df62a8c9a50db687d051f1c68", + "trial_id": "cells/tp2_mns64/low-rep1/result.json" + }, + "target": { + "requests_sha256": "016a76ab3dc015700f9ecb9f60a20fcc3b456c45270472fdd1d04e84ebd7021a", + "result_sha256": "368869326f44a0032985eff9d3abfa2306b93c25370caa05cee255a8c0208c0e", + "trial_id": "cells/tp2_mns64/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.008510638297872353, + "admitted_input_tokens_mean_over_limit": -0.08059763768960165, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.2543859649122807, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.2543859649122807, + "tpot_max_over_slo": -0.1787865552757903, + "tpot_mean_over_slo": -0.07545848129810456, + "ttft_max_over_slo_max": -0.024053132161498063, + "ttft_mean_over_slo_max": -0.008335181439306037 + }, + "delta_state": { + "batch_size.mean": -1.151692859112214, + "batch_tokens.mean": -39.27803694513372, + "decode_batch_size.mean": -1.1449765646539838, + "graph_full_share": 0.006457127102288407, + "graph_none_share": -0.008497380755445271, + "graph_padding_fraction": 6.114154911974513e-05, + "kv_usage_end_minus_start": 0.012533732366445394, + "kv_usage_max": -0.022906035375820144, + "kv_usage_mean": -0.00690787067830519, + "preemptions": 0.0, + "prefill_token_fraction": -0.0041771367400077475, + "queue_running_mean": -1.9580360157999994, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 14.099999999999994 + }, + "group": { + "cell": "tp2_mns64", + "level": "low", + "mns": 64, + "source_replicate": 2, + "target_replicate": 3, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "016a76ab3dc015700f9ecb9f60a20fcc3b456c45270472fdd1d04e84ebd7021a", + "result_sha256": "368869326f44a0032985eff9d3abfa2306b93c25370caa05cee255a8c0208c0e", + "trial_id": "cells/tp2_mns64/low-rep2/result.json" + }, + "target": { + "requests_sha256": "5455d1cdeabd6e2937130ed8fc8d86c1aaa6f04cbf26c3cb69ad064be5f67d73", + "result_sha256": "2de5c4524f57b487b94b4fdba35defc2a566236fc3e31f7260b7a9f85bb7007c", + "trial_id": "cells/tp2_mns64/low-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.01785714285714285, + "admitted_input_tokens_mean_over_limit": 0.0482287348533163, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.007421150278293154, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.007421150278293098, + "tpot_max_over_slo": 0.045055894329630586, + "tpot_mean_over_slo": 0.03517161669315627, + "ttft_max_over_slo_max": 0.04909342716564424, + "ttft_mean_over_slo_max": 0.07044418369208602 + }, + "delta_state": { + "batch_size.mean": 0.9503756445719365, + "batch_tokens.mean": 50.369704265273356, + "decode_batch_size.mean": 0.9415787316873265, + "graph_full_share": -0.009959703582283153, + "graph_none_share": 0.009959703582283236, + "graph_padding_fraction": -0.001694114329886807, + "kv_usage_end_minus_start": 0.0035348314893507427, + "kv_usage_max": 0.009660171254290972, + "kv_usage_mean": 0.004883298444633271, + "preemptions": 0.0, + "prefill_token_fraction": 0.007370470138318375, + "queue_running_mean": 0.27710616229999996, + "queue_waiting_mean": 1.1825361130999998, + "scheduler_steps_per_s": -17.900000000000006 + }, + "group": { + "cell": "tp2_mns8", + "level": "high", + "mns": 8, + "source_replicate": 1, + "target_replicate": 2, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "5d41a316f329e2efcc0f728cdd078377eb72fb9258738636db704bcfcca290aa", + "result_sha256": "466b3991190a232c984ba1b54fb6793cac1893dce196ee96f7238d70d49fcb74", + "trial_id": "cells/tp2_mns8/high-rep1/result.json" + }, + "target": { + "requests_sha256": "1b7d2cdcd639c00c443ae1b98287a7cc57323eb80c7f0e1bfc72f1ab5bf48760", + "result_sha256": "e9156d6871cc8cb3a20dce629cc2443df7473f3836b46eb0944d491ea5c4d44c", + "trial_id": "cells/tp2_mns8/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.005952380952380931, + "admitted_input_tokens_mean_over_limit": -0.08086076227365946, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.04961984793917562, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.049619847939175676, + "tpot_max_over_slo": -0.03665214141383477, + "tpot_mean_over_slo": -0.03040908016559296, + "ttft_max_over_slo_max": -0.06188676766275117, + "ttft_mean_over_slo_max": -0.061940220978646765 + }, + "delta_state": { + "batch_size.mean": -0.9308857183911066, + "batch_tokens.mean": -38.259866334430285, + "decode_batch_size.mean": -0.9247474057174099, + "graph_full_share": 0.009718264940999921, + "graph_none_share": -0.009718264941000004, + "graph_padding_fraction": 0.0021664497846041342, + "kv_usage_end_minus_start": 0.0029988642599186877, + "kv_usage_max": -0.006508173500248904, + "kv_usage_mean": -0.0037595414789287837, + "preemptions": 0.0, + "prefill_token_fraction": -0.0037648024150247483, + "queue_running_mean": -0.21647643550000062, + "queue_waiting_mean": -1.8036835434999998, + "scheduler_steps_per_s": 15.700000000000003 + }, + "group": { + "cell": "tp2_mns8", + "level": "high", + "mns": 8, + "source_replicate": 2, + "target_replicate": 3, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "1b7d2cdcd639c00c443ae1b98287a7cc57323eb80c7f0e1bfc72f1ab5bf48760", + "result_sha256": "e9156d6871cc8cb3a20dce629cc2443df7473f3836b46eb0944d491ea5c4d44c", + "trial_id": "cells/tp2_mns8/high-rep2/result.json" + }, + "target": { + "requests_sha256": "5a68fda7c29477e5b3e66d70ad2b05b77be6c200cc1beea89d663a5729f31a2b", + "result_sha256": "f2116797b35057949acbf1f57898befac9ff18b94c808462f0969bdcf2446dd6", + "trial_id": "cells/tp2_mns8/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.008733624454148492, + "admitted_input_tokens_mean_over_limit": 0.03586033261326227, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.07276507276507282, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.07276507276507277, + "tpot_max_over_slo": -0.00577808629105403, + "tpot_mean_over_slo": -0.014899153875042898, + "ttft_max_over_slo_max": 0.014347533161829545, + "ttft_mean_over_slo_max": 0.00013980660489499447 + }, + "delta_state": { + "batch_size.mean": -0.6370388590554663, + "batch_tokens.mean": -0.24447251544799542, + "decode_batch_size.mean": -0.6327331911137266, + "graph_full_share": 0.004305667941739033, + "graph_none_share": -0.004305667941739005, + "graph_padding_fraction": 0.0015483374551458753, + "kv_usage_end_minus_start": -0.0016334239373173576, + "kv_usage_max": 0.0027181195206921194, + "kv_usage_mean": -0.0003114508043975048, + "preemptions": 0.0, + "prefill_token_fraction": 0.005116159306570833, + "queue_running_mean": -0.5131508089000008, + "queue_waiting_mean": -0.13343640950000002, + "scheduler_steps_per_s": 7.5 + }, + "group": { + "cell": "tp2_mns8", + "level": "low", + "mns": 8, + "source_replicate": 1, + "target_replicate": 2, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "455a1c21388700f0e3234c49d15ba3b0426b0d3b551c096b297793afa0d4602f", + "result_sha256": "13de25a73cc8c752245f169cfca1d64220f697c15b835a646ba969a1005047fb", + "trial_id": "cells/tp2_mns8/low-rep1/result.json" + }, + "target": { + "requests_sha256": "cae4b764ebb8714a6f5d2009bb79497420b388986a992c51410f1681810c14c6", + "result_sha256": "92f92a576e990946c4767a2107d2ce0e6ba1b066337911399360c199fae3f5e4", + "trial_id": "cells/tp2_mns8/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.008733624454148464, + "admitted_input_tokens_mean_over_limit": -0.08428101999879345, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.23320463320463325, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.2332046332046332, + "tpot_max_over_slo": -0.02744940897875181, + "tpot_mean_over_slo": -0.059641868091682704, + "ttft_max_over_slo_max": -0.10803754650017558, + "ttft_mean_over_slo_max": -0.032639687448619975 + }, + "delta_state": { + "batch_size.mean": -1.203120302435217, + "batch_tokens.mean": -43.54127643086966, + "decode_batch_size.mean": -1.1934092223734076, + "graph_full_share": 0.010598391508127913, + "graph_none_share": -0.0105983915081279, + "graph_padding_fraction": 0.004406513335831962, + "kv_usage_end_minus_start": 0.00967293237880118, + "kv_usage_max": -0.008881742659163083, + "kv_usage_mean": -0.005494017047481575, + "preemptions": 0.0, + "prefill_token_fraction": -0.0054281680100684015, + "queue_running_mean": -1.7641761531999998, + "queue_waiting_mean": -0.32204582449999997, + "scheduler_steps_per_s": 15.600000000000009 + }, + "group": { + "cell": "tp2_mns8", + "level": "low", + "mns": 8, + "source_replicate": 2, + "target_replicate": 3, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "cae4b764ebb8714a6f5d2009bb79497420b388986a992c51410f1681810c14c6", + "result_sha256": "92f92a576e990946c4767a2107d2ce0e6ba1b066337911399360c199fae3f5e4", + "trial_id": "cells/tp2_mns8/low-rep2/result.json" + }, + "target": { + "requests_sha256": "cc8c01e4560411cd5b84cdc9bebdda9a86b88615ee1c39a996affe669d26c167", + "result_sha256": "c9a7d026bd89cc027c45b8f1899d56e21d53d4234e95db365a9492f670a78d36", + "trial_id": "cells/tp2_mns8/low-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.005333333333333329, + "admitted_input_tokens_mean_over_limit": 0.00313201278155667, + "completed_fail_fraction_of_total": 0.004, + "completed_over_admitted": 0.00267618198037467, + "completed_pass_rate": -0.048128342245989275, + "outstanding_over_admitted": -0.00267618198037467, + "tpot_max_over_slo": 0.01678296282344799, + "tpot_mean_over_slo": 0.03333551369285431, + "ttft_max_over_slo_max": 0.04254181500679499, + "ttft_mean_over_slo_max": 0.027600657575446386 + }, + "delta_state": { + "batch_size.mean": 2.617504152501592, + "batch_tokens.mean": 83.36000248373932, + "decode_batch_size.mean": 2.6009989288874404, + "graph_full_share": -0.030922553904903838, + "graph_none_share": 0.027604433474596013, + "graph_padding_fraction": -8.22833741022888e-05, + "kv_usage_end_minus_start": -0.001912904196656684, + "kv_usage_max": 0.0016425470701958433, + "kv_usage_mean": 0.002711903470305097, + "preemptions": 0.0, + "prefill_token_fraction": 0.0031462566114718316, + "queue_running_mean": 1.2096441719000008, + "queue_waiting_mean": 2.3781169752999993, + "scheduler_steps_per_s": -13.399999999999991 + }, + "group": { + "cell": "tp4_mns16", + "level": "high", + "mns": 16, + "source_replicate": 1, + "target_replicate": 2, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "8695422a0f1e0e1c097a08a7f4c082f1ba2e3bb26b58caadae0afc7438aeca90", + "result_sha256": "c54a2bb5c1b78bdef3fa09c39f5974215370d6fc7c2b6d403a3d376d53a1d9eb", + "trial_id": "cells/tp4_mns16/high-rep1/result.json" + }, + "target": { + "requests_sha256": "aa0482b10414d911af227e2df172c19ecca0add2e0024dc88f85ffbd063854bb", + "result_sha256": "91e2491de4ca0868b667e7d126b755f03bdd78378681b8070a2bbc0c38fb9055", + "trial_id": "cells/tp4_mns16/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.006666666666666654, + "admitted_input_tokens_mean_over_limit": -0.045669445146517385, + "completed_fail_fraction_of_total": -0.012, + "completed_over_admitted": 0.09077740222114916, + "completed_pass_rate": 0.13636363636363635, + "outstanding_over_admitted": -0.09077740222114916, + "tpot_max_over_slo": 0.006141297796037171, + "tpot_mean_over_slo": -0.021391237509928385, + "ttft_max_over_slo_max": -0.2410895283295152, + "ttft_mean_over_slo_max": -0.12306385203762282 + }, + "delta_state": { + "batch_size.mean": 0.023181238824859562, + "batch_tokens.mean": 2.5905518549044473, + "decode_batch_size.mean": 0.011653673102646422, + "graph_full_share": 0.0012768372268986417, + "graph_none_share": 0.001837564686330409, + "graph_padding_fraction": 0.0006975685594821312, + "kv_usage_end_minus_start": 0.001387493177308352, + "kv_usage_max": 0.0022138677902641124, + "kv_usage_mean": -0.0011780510256150529, + "preemptions": 0.0, + "prefill_token_fraction": 0.0002680116189619497, + "queue_running_mean": 0.1377117206999987, + "queue_waiting_mean": -11.247484751, + "scheduler_steps_per_s": 2.5 + }, + "group": { + "cell": "tp4_mns16", + "level": "high", + "mns": 16, + "source_replicate": 2, + "target_replicate": 3, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "aa0482b10414d911af227e2df172c19ecca0add2e0024dc88f85ffbd063854bb", + "result_sha256": "91e2491de4ca0868b667e7d126b755f03bdd78378681b8070a2bbc0c38fb9055", + "trial_id": "cells/tp4_mns16/high-rep2/result.json" + }, + "target": { + "requests_sha256": "3a23ffbe0e724648226152ef5433cc5825ad640c37cf47997c2f091210eceeec", + "result_sha256": "136dde0451f806841ff3996b081fe0bffac0a76f60c3d78b7516f2689e106008", + "trial_id": "cells/tp4_mns16/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0215686274509804, + "admitted_input_tokens_mean_over_limit": -0.007677676072761208, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.12342135476463834, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.12342135476463834, + "tpot_max_over_slo": 0.042659409131532156, + "tpot_mean_over_slo": 0.06205778281240598, + "ttft_max_over_slo_max": 0.09863472549477593, + "ttft_mean_over_slo_max": 0.04373689836276399 + }, + "delta_state": { + "batch_size.mean": 3.8253490040280305, + "batch_tokens.mean": 77.16682826085241, + "decode_batch_size.mean": 3.80033895365794, + "graph_full_share": -0.03715089743892919, + "graph_none_share": 0.034228013337432306, + "graph_padding_fraction": -0.0048637698153220395, + "kv_usage_end_minus_start": -0.007677122175915652, + "kv_usage_max": 0.005958058937853616, + "kv_usage_mean": 0.004083928262059737, + "preemptions": 0.0, + "prefill_token_fraction": -0.0015885934328132567, + "queue_running_mean": 4.248843562199999, + "queue_waiting_mean": 1.9316373561999998, + "scheduler_steps_per_s": -12.799999999999997 + }, + "group": { + "cell": "tp4_mns16", + "level": "low", + "mns": 16, + "source_replicate": 1, + "target_replicate": 2, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "d7eaaefd35cc906f759dcaa7ac3c8543249a1a02f28572bec953e41e4379a29f", + "result_sha256": "11d9ec9d2a3358aed988f7b4b1014af087d61c4b5a72eb9076ae19bb5cc481cd", + "trial_id": "cells/tp4_mns16/low-rep1/result.json" + }, + "target": { + "requests_sha256": "7fdb90f679bba1747fbacc92fac2045c820e09965c755b20f6dafd4fd9e26a7a", + "result_sha256": "800e2aa6e9f9efef4be12ee778be6817364914d63ae0624775d02729089768d6", + "trial_id": "cells/tp4_mns16/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.023529411764705882, + "admitted_input_tokens_mean_over_limit": 0.013229832504734862, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.1573426573426573, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.15734265734265732, + "tpot_max_over_slo": -0.05231123732945586, + "tpot_mean_over_slo": -0.08222875707353122, + "ttft_max_over_slo_max": -0.11858330133448666, + "ttft_mean_over_slo_max": -0.04432077170326809 + }, + "delta_state": { + "batch_size.mean": -6.136759360232643, + "batch_tokens.mean": -119.22330840733238, + "decode_batch_size.mean": -6.093614010489692, + "graph_full_share": 0.04765150334943136, + "graph_none_share": -0.049295061536064805, + "graph_padding_fraction": 0.001850754011979509, + "kv_usage_end_minus_start": 0.00735065319301953, + "kv_usage_max": -0.003932931028326259, + "kv_usage_mean": -0.00419858552745247, + "preemptions": 0.0, + "prefill_token_fraction": 0.0044424417100876745, + "queue_running_mean": -5.4834562212, + "queue_waiting_mean": -1.804526599, + "scheduler_steps_per_s": 31.299999999999997 + }, + "group": { + "cell": "tp4_mns16", + "level": "low", + "mns": 16, + "source_replicate": 2, + "target_replicate": 3, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "7fdb90f679bba1747fbacc92fac2045c820e09965c755b20f6dafd4fd9e26a7a", + "result_sha256": "800e2aa6e9f9efef4be12ee778be6817364914d63ae0624775d02729089768d6", + "trial_id": "cells/tp4_mns16/low-rep2/result.json" + }, + "target": { + "requests_sha256": "b592fe254476957265fc9139aefdea77be4b5540f3c1b8a429c10ea6ccab9a6a", + "result_sha256": "cc1b1f7f5280c2892d0c6deac9df9f34ce126b0284e6ad893ffbf0ddbf27969f", + "trial_id": "cells/tp4_mns16/low-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.005333333333333329, + "admitted_input_tokens_mean_over_limit": 0.00313201278155667, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.005798394290811748, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.005798394290811748, + "tpot_max_over_slo": 0.1973487464546072, + "tpot_mean_over_slo": 0.10397174357977113, + "ttft_max_over_slo_max": -0.001787370662592977, + "ttft_mean_over_slo_max": 0.007868458508126674 + }, + "delta_state": { + "batch_size.mean": 11.95331828442438, + "batch_tokens.mean": 306.10848411182496, + "decode_batch_size.mean": 11.860920298662965, + "graph_full_share": -0.07233894773398164, + "graph_none_share": 0.06742142733113388, + "graph_padding_fraction": -0.0007349090714318936, + "kv_usage_end_minus_start": -0.0056930844866003305, + "kv_usage_max": -0.005488664935914489, + "kv_usage_mean": 0.006218554442237678, + "preemptions": 0.0, + "prefill_token_fraction": -0.002281107503328106, + "queue_running_mean": 4.266314980200001, + "queue_waiting_mean": -0.038871071699999996, + "scheduler_steps_per_s": -11.799999999999997 + }, + "group": { + "cell": "tp4_mns64", + "level": "high", + "mns": 64, + "source_replicate": 1, + "target_replicate": 2, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "b4aeaf5b3175bd85fdac08a2ef657fb2278c6c4b36ea32ea417275ab6d55812d", + "result_sha256": "111a1042b614d05772888665a7cfbc86925b2fbeb52ffe19edb62a5bcfe2f513", + "trial_id": "cells/tp4_mns64/high-rep1/result.json" + }, + "target": { + "requests_sha256": "5d82b6885f5c654ae1ae126696df4bafe04f5be1c1109db24c7856b0456d9443", + "result_sha256": "6ed574c18723e265ab1327c5e43d3c76d37b3fc5711d06c77a51718e4ba16601", + "trial_id": "cells/tp4_mns64/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.006666666666666654, + "admitted_input_tokens_mean_over_limit": -0.045669445146517385, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.1202317720907774, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.1202317720907774, + "tpot_max_over_slo": -0.2208674842524746, + "tpot_mean_over_slo": -0.3211407366971467, + "ttft_max_over_slo_max": -0.007970502677684024, + "ttft_mean_over_slo_max": -0.009044386120380173 + }, + "delta_state": { + "batch_size.mean": -17.26249134948097, + "batch_tokens.mean": -537.2182539260048, + "decode_batch_size.mean": -17.083955283470857, + "graph_full_share": 0.10428533404311957, + "graph_none_share": -0.09966462603140805, + "graph_padding_fraction": 0.004369015708508233, + "kv_usage_end_minus_start": -0.020942782967763085, + "kv_usage_max": -0.019762260062552328, + "kv_usage_mean": -0.018462380855259714, + "preemptions": 0.0, + "prefill_token_fraction": -0.0019184118517130422, + "queue_running_mean": -18.914856451900004, + "queue_waiting_mean": -0.0374047109, + "scheduler_steps_per_s": 25.299999999999997 + }, + "group": { + "cell": "tp4_mns64", + "level": "high", + "mns": 64, + "source_replicate": 2, + "target_replicate": 3, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "5d82b6885f5c654ae1ae126696df4bafe04f5be1c1109db24c7856b0456d9443", + "result_sha256": "6ed574c18723e265ab1327c5e43d3c76d37b3fc5711d06c77a51718e4ba16601", + "trial_id": "cells/tp4_mns64/high-rep2/result.json" + }, + "target": { + "requests_sha256": "5c5861d716181f06dc3f951ae0d6ee479b1b61fc21ebf24541c5b45053fcc167", + "result_sha256": "35b8f0465f6b0c197f71b5ecaf4e771e6613f86998ae44f8701ab9e4e1e440b4", + "trial_id": "cells/tp4_mns64/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0215686274509804, + "admitted_input_tokens_mean_over_limit": -0.007677676072761208, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.17470340604668966, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.17470340604668963, + "tpot_max_over_slo": 0.048643136378671015, + "tpot_mean_over_slo": 0.059397215574861106, + "ttft_max_over_slo_max": 0.01085578350466676, + "ttft_mean_over_slo_max": 0.0005479300281428442 + }, + "delta_state": { + "batch_size.mean": 3.3204058305140567, + "batch_tokens.mean": 67.87133685773168, + "decode_batch_size.mean": 3.294527414991851, + "graph_full_share": -0.02348818567751032, + "graph_none_share": 0.022293070755162486, + "graph_padding_fraction": -0.0005360553529459057, + "kv_usage_end_minus_start": -0.010353850242237006, + "kv_usage_max": 0.004231484699196653, + "kv_usage_mean": 0.0043582810100513195, + "preemptions": 0.0, + "prefill_token_fraction": -0.001346586578878206, + "queue_running_mean": 4.306671635299999, + "queue_waiting_mean": -0.000525882, + "scheduler_steps_per_s": -14.100000000000009 + }, + "group": { + "cell": "tp4_mns64", + "level": "low", + "mns": 64, + "source_replicate": 1, + "target_replicate": 2, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "931d372ded1e3aaa9c67f06653fac8f79b4ee4f369028c1148163580386681ce", + "result_sha256": "325ce57f33133670a6761b5dffb831ed3b2f464755ff743b56976b4a974c1215", + "trial_id": "cells/tp4_mns64/low-rep1/result.json" + }, + "target": { + "requests_sha256": "72c8f70a240f79edcaa4eb0a2fe9bade8ac07093339c5b2d09c49ddd1cf27d16", + "result_sha256": "ff8b2283d02d5967893ca6225b561ae11011da6149d1f6cff7b4275c00170e1d", + "trial_id": "cells/tp4_mns64/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.023529411764705882, + "admitted_input_tokens_mean_over_limit": 0.013229832504734862, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.2086247086247086, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.2086247086247086, + "tpot_max_over_slo": -0.049497940473067825, + "tpot_mean_over_slo": -0.07097474071479923, + "ttft_max_over_slo_max": 0.0113132930030891, + "ttft_mean_over_slo_max": 0.0027290206974555573 + }, + "delta_state": { + "batch_size.mean": -4.516372320824056, + "batch_tokens.mean": -75.80960433136954, + "decode_batch_size.mean": -4.485458989758809, + "graph_full_share": 0.024653639771889058, + "graph_none_share": -0.023884511783377624, + "graph_padding_fraction": -0.0020895387371847093, + "kv_usage_end_minus_start": 0.011432163372104731, + "kv_usage_max": -0.003015188372616051, + "kv_usage_mean": -0.004106181760760127, + "preemptions": 0.0, + "prefill_token_fraction": 0.006171117400546322, + "queue_running_mean": -5.0125981476999995, + "queue_waiting_mean": 0.000454857, + "scheduler_steps_per_s": 21.80000000000001 + }, + "group": { + "cell": "tp4_mns64", + "level": "low", + "mns": 64, + "source_replicate": 2, + "target_replicate": 3, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "72c8f70a240f79edcaa4eb0a2fe9bade8ac07093339c5b2d09c49ddd1cf27d16", + "result_sha256": "ff8b2283d02d5967893ca6225b561ae11011da6149d1f6cff7b4275c00170e1d", + "trial_id": "cells/tp4_mns64/low-rep2/result.json" + }, + "target": { + "requests_sha256": "8b2c779d2097c5e4038e94e1ac9b986e29f55d9acfd67eeb366c4e0e9270f6e0", + "result_sha256": "f026b69356701894fab184e0f2f7504a30b537982e823373899c9ab123a33891", + "trial_id": "cells/tp4_mns64/low-rep3/result.json" + } + } + ], + "response_statistics": { + "batch_size.mean": { + "action_above_repeat_p95_fraction": 0.08333333333333333, + "action_abs_median": 0.6185880702088911, + "action_delta": { + "distinct_n": 12, + "max": 19.42960244648318, + "min": -1.4718645603306726, + "n": 12 + }, + "action_signs": { + "consistency": 0.6666666666666666, + "negative": 4, + "positive": 8, + "zero": 0 + }, + "effect_to_repeat_median": 0.2658268122367889, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 2.327034150557677, + "repeat_abs_p95": 11.456264844377335, + "repeat_delta": { + "distinct_n": 24, + "max": 11.95331828442438, + "min": -17.26249134948097, + "n": 24 + } + }, + "batch_tokens.mean": { + "action_above_repeat_p95_fraction": 0.16666666666666666, + "action_abs_median": 17.059106336421053, + "action_delta": { + "distinct_n": 12, + "max": 656.7778499176663, + "min": -31.86018426395526, + "n": 12 + }, + "action_signs": { + "consistency": 0.5833333333333334, + "negative": 5, + "positive": 7, + "zero": 0 + }, + "effect_to_repeat_median": 0.2374581652269279, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 71.84047059455061, + "repeat_abs_p95": 327.5325978555095, + "repeat_delta": { + "distinct_n": 24, + "max": 306.10848411182496, + "min": -537.2182539260048, + "n": 24 + } + }, + "decode_batch_size.mean": { + "action_above_repeat_p95_fraction": 0.08333333333333333, + "action_abs_median": 0.6115154242137617, + "action_delta": { + "distinct_n": 12, + "max": 19.184206069160197, + "min": -1.4608669627184998, + "n": 12 + }, + "action_signs": { + "consistency": 0.6666666666666666, + "negative": 4, + "positive": 8, + "zero": 0 + }, + "effect_to_repeat_median": 0.2650837352505827, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 2.3068764427802346, + "repeat_abs_p95": 11.363988993022012, + "repeat_delta": { + "distinct_n": 24, + "max": 11.860920298662965, + "min": -17.083955283470857, + "n": 24 + } + }, + "graph_full_share": { + "action_above_repeat_p95_fraction": 0.16666666666666666, + "action_abs_median": 0.005588197661352101, + "action_delta": { + "distinct_n": 12, + "max": 0.02356281394840931, + "min": -0.13147494707127738, + "n": 12 + }, + "action_signs": { + "consistency": 0.5833333333333334, + "negative": 7, + "positive": 5, + "zero": 0 + }, + "effect_to_repeat_median": 0.27121228977463446, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.020604514883878045, + "repeat_abs_p95": 0.08279928773704351, + "repeat_delta": { + "distinct_n": 24, + "max": 0.10428533404311957, + "min": -0.07611315423133669, + "n": 24 + } + }, + "graph_none_share": { + "action_above_repeat_p95_fraction": 0.08333333333333333, + "action_abs_median": 0.011395045691744581, + "action_delta": { + "distinct_n": 12, + "max": 0.11760056457304163, + "min": -0.027804605789997328, + "n": 12 + }, + "action_signs": { + "consistency": 0.6666666666666666, + "negative": 8, + "positive": 4, + "zero": 0 + }, + "effect_to_repeat_median": 0.5196295717736035, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.02192917091467856, + "repeat_abs_p95": 0.08301950470733124, + "repeat_delta": { + "distinct_n": 24, + "max": 0.08050759417399073, + "min": -0.09966462603140805, + "n": 24 + } + }, + "graph_padding_fraction": { + "action_above_repeat_p95_fraction": 0.08333333333333333, + "action_abs_median": 0.0024624382794725458, + "action_delta": { + "distinct_n": 12, + "max": 0.008784696835623326, + "min": -0.0007445684074620391, + "n": 12 + }, + "action_signs": { + "consistency": 0.8333333333333334, + "negative": 2, + "positive": 10, + "zero": 0 + }, + "effect_to_repeat_median": 1.15716396642797, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.0021279942608944218, + "repeat_abs_p95": 0.007335491197810787, + "repeat_delta": { + "distinct_n": 24, + "max": 0.0086692890425959, + "min": -0.007424342975302652, + "n": 24 + } + }, + "kv_usage_end_minus_start": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.0009122627395202754, + "action_delta": { + "distinct_n": 12, + "max": 0.05537535994708087, + "min": -0.002621229743826836, + "n": 12 + }, + "action_signs": { + "consistency": 0.9166666666666666, + "negative": 1, + "positive": 11, + "zero": 0 + }, + "effect_to_repeat_median": 0.08374755984910728, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.010893006807170869, + "repeat_abs_p95": 0.08088054822007018, + "repeat_delta": { + "distinct_n": 24, + "max": 0.08232590668398432, + "min": -0.12798481366769898, + "n": 24 + } + }, + "kv_usage_max": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.0070274347692272365, + "action_delta": { + "distinct_n": 12, + "max": 0.08922043547542868, + "min": 0.0002683613903166071, + "n": 12 + }, + "action_signs": { + "consistency": 1.0, + "negative": 0, + "positive": 12, + "zero": 0 + }, + "effect_to_repeat_median": 0.49974360815926006, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.014062080343782424, + "repeat_abs_p95": 0.10858976920771296, + "repeat_delta": { + "distinct_n": 24, + "max": 0.11409731241882304, + "min": -0.12688580277750028, + "n": 24 + } + }, + "kv_usage_mean": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.0019193628331501261, + "action_delta": { + "distinct_n": 12, + "max": 0.04639671324585863, + "min": -0.0003621004636635179, + "n": 12 + }, + "action_signs": { + "consistency": 0.75, + "negative": 3, + "positive": 9, + "zero": 0 + }, + "effect_to_repeat_median": 0.29244258288516367, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.006563212560271434, + "repeat_abs_p95": 0.08042579042638397, + "repeat_delta": { + "distinct_n": 24, + "max": 0.08571139047521727, + "min": -0.09580544440945148, + "n": 24 + } + }, + "preemptions": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.0, + "action_delta": { + "distinct_n": 1, + "max": 0.0, + "min": 0.0, + "n": 12 + }, + "action_signs": { + "consistency": 0.0, + "negative": 0, + "positive": 0, + "zero": 12 + }, + "effect_to_repeat_median": 0.0, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.0, + "repeat_abs_p95": 0.0, + "repeat_delta": { + "distinct_n": 1, + "max": 0.0, + "min": 0.0, + "n": 24 + } + }, + "prefill_token_fraction": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.00026550413778614335, + "action_delta": { + "distinct_n": 12, + "max": 0.013365962658000052, + "min": -0.0003954091503666213, + "n": 12 + }, + "action_signs": { + "consistency": 0.6666666666666666, + "negative": 4, + "positive": 8, + "zero": 0 + }, + "effect_to_repeat_median": 0.05125991549197503, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.005179566435838334, + "repeat_abs_p95": 0.0190949186571384, + "repeat_delta": { + "distinct_n": 24, + "max": 0.011636868678620127, + "min": -0.024511024899494305, + "n": 24 + } + }, + "queue_running_mean": { + "action_above_repeat_p95_fraction": 0.16666666666666666, + "action_abs_median": 0.43384798364999977, + "action_delta": { + "distinct_n": 12, + "max": 24.0049637595, + "min": -0.46276202019999957, + "n": 12 + }, + "action_signs": { + "consistency": 0.6666666666666666, + "negative": 4, + "positive": 8, + "zero": 0 + }, + "effect_to_repeat_median": 0.1773939239284337, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 2.4456755566499995, + "repeat_abs_p95": 7.584720893309999, + "repeat_delta": { + "distinct_n": 24, + "max": 7.2005321570000005, + "min": -18.914856451900004, + "n": 24 + } + }, + "queue_waiting_mean": { + "action_above_repeat_p95_fraction": 0.25, + "action_abs_median": 0.22497528095, + "action_delta": { + "distinct_n": 11, + "max": 0.0, + "min": -15.5760687653, + "n": 12 + }, + "action_signs": { + "consistency": 1.0, + "negative": 10, + "positive": 0, + "zero": 2 + }, + "effect_to_repeat_median": 2.611323424650003, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.0861537406, + "repeat_abs_p95": 2.3661207382899994, + "repeat_delta": { + "distinct_n": 17, + "max": 2.3781169752999993, + "min": -11.247484751, + "n": 24 + } + }, + "scheduler_steps_per_s": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 6.950000000000006, + "action_delta": { + "distinct_n": 11, + "max": 11.900000000000006, + "min": -34.5, + "n": 12 + }, + "action_signs": { + "consistency": 0.5, + "negative": 6, + "positive": 6, + "zero": 0 + }, + "effect_to_repeat_median": 0.44408945686900986, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 15.650000000000006, + "repeat_abs_p95": 50.385, + "repeat_delta": { + "distinct_n": 24, + "max": 65.0, + "min": -46.900000000000006, + "n": 24 + } + } + }, + "sanity": { + "action_pairs": 12, + "invariants": { + "efficacy_label_balance": true, + "expected_action_pair_count": true, + "expected_repeat_pair_count": true, + "finite_deltas": true, + "matched_action_request_hashes": true, + "probabilities_bounded": true + }, + "red_flags": [], + "repeat_pairs": 24, + "trials": 36 + } + }, + "5": { + "actions": [ + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.0, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.0, + "tpot_max_over_slo": -0.0008452736944928041, + "tpot_mean_over_slo": -0.0021708008398531042, + "ttft_max_over_slo_max": -0.00014104516594670713, + "ttft_mean_over_slo_max": -0.00020825385150534392 + }, + "delta_state": { + "batch_size.mean": -0.06880455035794819, + "batch_tokens.mean": -1.0156712758654507, + "decode_batch_size.mean": -0.067941551436697, + "graph_full_share": 0.0008629989212514122, + "graph_none_share": -0.006688241639697952, + "graph_padding_fraction": 0.00030316259031496623, + "kv_usage_end_minus_start": 2.700440393244019e-05, + "kv_usage_max": 0.00012663114366773254, + "kv_usage_mean": -6.934750080297807e-05, + "preemptions": 0.0, + "prefill_token_fraction": -0.000948468871704522, + "queue_running_mean": -0.028601565200000234, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 4.0 + }, + "full_action_efficacy": 0, + "full_feasibility_transition": "false->false", + "group": { + "level": "high", + "offered_rate_per_gpu": 2.9833333333333334, + "replicate": 1, + "request_hash": "3f0ab9be34dbee884f5dbe2135b983d31a47578a43f606a5f390b0528dbedbe3", + "tp": 1 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.20670391061452514, + "mns": 8, + "requests_sha256": "5f5bfa4a16846190f488d3369eed89ae895804145cea59197e6b544b703223fc", + "result_sha256": "f65e3dc91d17f5caab1f4aecf97d2c464b99f107231af2cfd96f5484880136ee", + "trial_id": "cells/tp1_mns8/high-rep1/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.24581005586592178, + "mns": 64, + "requests_sha256": "e970dcac20144cb1e13a35997377f6695a9c57d788a88bad7f18cf6c64e35cec", + "result_sha256": "3233686b60b920dcd6cc2f45193a81f3af2d46f781ef42c4d117630612084feb", + "trial_id": "cells/tp1_mns64/high-rep1/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.375, + "completed_pass_rate": -1.0, + "outstanding_over_admitted": 0.375, + "tpot_max_over_slo": -0.562845061415821, + "tpot_mean_over_slo": -0.49685783692809143, + "ttft_max_over_slo_max": -0.1160576971694051, + "ttft_mean_over_slo_max": -0.06709235994559196 + }, + "delta_state": { + "batch_size.mean": 1.9650793650793652, + "batch_tokens.mean": 127.72380952380956, + "decode_batch_size.mean": 1.9158730158730162, + "graph_full_share": -0.041269841269841345, + "graph_none_share": 0.033333333333333326, + "graph_padding_fraction": 0.0032253509426556993, + "kv_usage_end_minus_start": 0.08606331121732713, + "kv_usage_max": 0.04171319199456147, + "kv_usage_mean": 0.01377304273482051, + "preemptions": 0.0, + "prefill_token_fraction": 0.0018893720284961502, + "queue_running_mean": 1.9109891312, + "queue_waiting_mean": -1.558876379, + "scheduler_steps_per_s": -10.8 + }, + "full_action_efficacy": 0, + "full_feasibility_transition": "false->false", + "group": { + "level": "high", + "offered_rate_per_gpu": 2.9833333333333334, + "replicate": 2, + "request_hash": "b19c91876a8417fe06cb2775f65a1111b202f88ce10ec33576af3d84c059f02a", + "tp": 1 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.7988826815642458, + "mns": 8, + "requests_sha256": "e802d09057de349e5164c18314fcad09dc88c9673834fd6e5b100a57dd12fbf4", + "result_sha256": "4835a985dd6bb8dc50b53737baa980ac95a49e22f0b8a7326e1fb416c9b4e798", + "trial_id": "cells/tp1_mns8/high-rep2/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.88268156424581, + "mns": 64, + "requests_sha256": "ec06878e2aefdc4853d972197cedc29ab94df7147abb2701e0d88b5dabf29728", + "result_sha256": "8215477a014f061c55e94d879a25bbf1676ee2ef1c5e81efadd23d20d337e07a", + "trial_id": "cells/tp1_mns64/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.0, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.0, + "tpot_max_over_slo": -0.003354239532372044, + "tpot_mean_over_slo": -0.002150681978709712, + "ttft_max_over_slo_max": -0.0004135148386315776, + "ttft_mean_over_slo_max": -0.00028004554942959864 + }, + "delta_state": { + "batch_size.mean": -0.03143779072203845, + "batch_tokens.mean": -11.489561245442736, + "decode_batch_size.mean": -0.02922096970204935, + "graph_full_share": 0.0022168210199891014, + "graph_none_share": -0.00629845367305033, + "graph_padding_fraction": 0.001725218661472923, + "kv_usage_end_minus_start": -0.01687018923627459, + "kv_usage_max": -0.01682167078536223, + "kv_usage_mean": -0.00010651327558790225, + "preemptions": 0.0, + "prefill_token_fraction": -0.009907841139181417, + "queue_running_mean": -0.027900191600000124, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.5999999999999943 + }, + "full_action_efficacy": 0, + "full_feasibility_transition": "false->false", + "group": { + "level": "high", + "offered_rate_per_gpu": 2.9833333333333334, + "replicate": 3, + "request_hash": "a85849f1f057a67c82523cff57a52af22d2eb9514a953e076990aa6c25c1ef7e", + "tp": 1 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.6424581005586593, + "mns": 8, + "requests_sha256": "cf1226185845cd8aa4e7ead0cb5c95c77eda62b84851a2ab579f984bbb88e8ac", + "result_sha256": "95d5103f2678eeb99c258870324566932e2f2853c3b6e0ee94bc6c538f6ed865", + "trial_id": "cells/tp1_mns8/high-rep3/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.9273743016759777, + "mns": 64, + "requests_sha256": "18d72d1fe16136359e28a1909e395ffd553dbe3edd2c0fd93a9cc270a5ec6d60", + "result_sha256": "480a3b50acaf9b9c1902e2669cf3aa7723a6703a00778da269b5b9757990ceef", + "trial_id": "cells/tp1_mns64/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.0, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.0, + "tpot_max_over_slo": -0.019319413383821316, + "tpot_mean_over_slo": -0.01717012501436968, + "ttft_max_over_slo_max": -0.0006420235052549544, + "ttft_mean_over_slo_max": -0.0016948439976355693 + }, + "delta_state": { + "batch_size.mean": -0.06047484495981781, + "batch_tokens.mean": -1.7159186818832382, + "decode_batch_size.mean": -0.059649187185791375, + "graph_full_share": 0.0008256577740266557, + "graph_none_share": -0.007128178782430002, + "graph_padding_fraction": 0.0006142370124512038, + "kv_usage_end_minus_start": 9.20038674978585e-05, + "kv_usage_max": 0.00016629145416469093, + "kv_usage_mean": -5.445550568086016e-05, + "preemptions": 0.0, + "prefill_token_fraction": -0.00036424705933824075, + "queue_running_mean": -0.16474551560000017, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 3.6000000000000085 + }, + "full_action_efficacy": 0, + "full_feasibility_transition": "true->true", + "group": { + "level": "low", + "offered_rate_per_gpu": 2.033333333333333, + "replicate": 1, + "request_hash": "c8ea9278f180ebb23cee595e167627cbed711032e70c9ca5ddc7205320cd75c0", + "tp": 1 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "requests_sha256": "0edc6095b16e5361a88b2765cc5d0f267ed16ff1d883e02fc3c58f57e59c1018", + "result_sha256": "8bc433109d148c21b7d158df95ec5d1fa4fa619243114563068e1e98c4241a29", + "trial_id": "cells/tp1_mns8/low-rep1/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "44d729c1ace9b09fe2ea4c4e110bd0f95fee69f83edc78ee0f65256922dcd2c2", + "result_sha256": "d2c08e71c5d4e0dd99662bab8457bd1ad0a4aba6bda57794dbfce62e36720f62", + "trial_id": "cells/tp1_mns64/low-rep1/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.15384615384615385, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.15384615384615385, + "tpot_max_over_slo": 0.040732697633234394, + "tpot_mean_over_slo": 0.014527851366132327, + "ttft_max_over_slo_max": -0.03623925517119157, + "ttft_mean_over_slo_max": -0.015724865515949205 + }, + "delta_state": { + "batch_size.mean": 0.05866351271436976, + "batch_tokens.mean": 16.67403903015969, + "decode_batch_size.mean": 0.053696037847427824, + "graph_full_share": 0.0010053222945002327, + "graph_none_share": -0.012241277350680077, + "graph_padding_fraction": 0.0038721626639551332, + "kv_usage_end_minus_start": 0.02762750849475526, + "kv_usage_max": 0.01654350181309283, + "kv_usage_mean": 0.004906340576442361, + "preemptions": 0.0, + "prefill_token_fraction": 0.0010152672534560203, + "queue_running_mean": 0.6418094667999998, + "queue_waiting_mean": -0.3949698864, + "scheduler_steps_per_s": -2.3999999999999986 + }, + "full_action_efficacy": 0, + "full_feasibility_transition": "true->true", + "group": { + "level": "low", + "offered_rate_per_gpu": 2.033333333333333, + "replicate": 2, + "request_hash": "1f27fe31ca32fd67f2f70a54eee83146329a7838ff2a33be48ce4372640a858c", + "tp": 1 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "requests_sha256": "ca58a878401ac44cca0a9a595eab41659dafec2e923f7f2474e4f82ea30b2f3e", + "result_sha256": "42a56af136d1d3bdfc16d9cea092c2db0eaa4db2c85dceb21958c5e418122900", + "trial_id": "cells/tp1_mns8/low-rep2/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "97de3cced64fd88a5c2dcd087ca6c29d8b09a0a43d7bf0e4e844ef246462465b", + "result_sha256": "f194db2f7abb995171cd24626e4e515c000481f81283c929b9a5b63f110f1506", + "trial_id": "cells/tp1_mns64/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.0, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.0, + "tpot_max_over_slo": -0.0007078415662871984, + "tpot_mean_over_slo": -0.000578866876769335, + "ttft_max_over_slo_max": -5.364099827906421e-05, + "ttft_mean_over_slo_max": 4.2679616146623633e-05 + }, + "delta_state": { + "batch_size.mean": -0.001802258455126493, + "batch_tokens.mean": -0.2360817774774091, + "decode_batch_size.mean": -0.00173185773422313, + "graph_full_share": 7.040072090336302e-05, + "graph_none_share": -7.040072090338037e-05, + "graph_padding_fraction": 0.0, + "kv_usage_end_minus_start": 0.00011716903913294718, + "kv_usage_max": 0.00013871042605262396, + "kv_usage_mean": 8.130641993444807e-06, + "preemptions": 0.0, + "prefill_token_fraction": -3.2355679021600636e-05, + "queue_running_mean": -0.0025477285999999655, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.19999999999999574 + }, + "full_action_efficacy": 0, + "full_feasibility_transition": "true->true", + "group": { + "level": "low", + "offered_rate_per_gpu": 2.033333333333333, + "replicate": 3, + "request_hash": "a46c62ebd8b7df5534831feb70aed45d23b1a5e7f8bf3d4cd82a79f182fbc69e", + "tp": 1 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "requests_sha256": "8a72240f84bbeff9eabd63e7d1f7a4c19910660fc5e4335013a1deaf89408127", + "result_sha256": "0214f32cabbcdc1bad6c331c3945c505cad136fcc9a8336aeb6314b27474e279", + "trial_id": "cells/tp1_mns8/low-rep3/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "30f4623100c58580cfa4efe9a1998c63581c8e44511c556ef39cf5bd777883bf", + "result_sha256": "0be457aa2fc9ce95bdb92a6eb25544f5f61a9739932ee5afa40535d26456e348", + "trial_id": "cells/tp1_mns64/low-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.27586206896551724, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.27586206896551724, + "tpot_max_over_slo": 0.207529695590914, + "tpot_mean_over_slo": 0.05943365186246716, + "ttft_max_over_slo_max": -0.10603234449323887, + "ttft_mean_over_slo_max": -0.017237129418515705 + }, + "delta_state": { + "batch_size.mean": 4.237397287896355, + "batch_tokens.mean": 201.35936633563546, + "decode_batch_size.mean": 4.139436406714726, + "graph_full_share": -0.05746836719261983, + "graph_none_share": 0.044500176437969455, + "graph_padding_fraction": 0.0022441507829442276, + "kv_usage_end_minus_start": 0.02343349054119659, + "kv_usage_max": 0.0207004044749316, + "kv_usage_mean": 0.007304490614720681, + "preemptions": 0.0, + "prefill_token_fraction": 0.016050535408914768, + "queue_running_mean": 9.929849956000002, + "queue_waiting_mean": -5.506802823999999, + "scheduler_steps_per_s": -29.19999999999999 + }, + "full_action_efficacy": 1, + "full_feasibility_transition": "false->true", + "group": { + "level": "high", + "offered_rate_per_gpu": 3.125, + "replicate": 1, + "request_hash": "5240182174ec5e25247be01c017cbefe2f1e59426bb24a57746dc40be4a82208", + "tp": 4 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.10666666666666667, + "mns": 16, + "requests_sha256": "8695422a0f1e0e1c097a08a7f4c082f1ba2e3bb26b58caadae0afc7438aeca90", + "result_sha256": "c54a2bb5c1b78bdef3fa09c39f5974215370d6fc7c2b6d403a3d376d53a1d9eb", + "trial_id": "cells/tp4_mns16/high-rep1/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "b4aeaf5b3175bd85fdac08a2ef657fb2278c6c4b36ea32ea417275ab6d55812d", + "result_sha256": "111a1042b614d05772888665a7cfbc86925b2fbeb52ffe19edb62a5bcfe2f513", + "trial_id": "cells/tp4_mns64/high-rep1/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.2631578947368421, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.26315789473684204, + "tpot_max_over_slo": 0.2331512886664177, + "tpot_mean_over_slo": 0.22120977902069205, + "ttft_max_over_slo_max": -0.17202288067589203, + "ttft_mean_over_slo_max": -0.05936201432352671 + }, + "delta_state": { + "batch_size.mean": 10.325762195121952, + "batch_tokens.mean": 461.67439024390245, + "decode_batch_size.mean": 10.164329268292683, + "graph_full_share": -0.08612804878048774, + "graph_none_share": 0.07111280487804877, + "graph_padding_fraction": 0.0007778735353099922, + "kv_usage_end_minus_start": 0.03093665701006798, + "kv_usage_max": 0.026463529328836888, + "kv_usage_mean": 0.010597923626744828, + "preemptions": 0.0, + "prefill_token_fraction": 0.009329314654311416, + "queue_running_mean": 12.835752482200002, + "queue_waiting_mean": -6.7273728942, + "scheduler_steps_per_s": -23.0 + }, + "full_action_efficacy": 1, + "full_feasibility_transition": "false->true", + "group": { + "level": "high", + "offered_rate_per_gpu": 3.125, + "replicate": 2, + "request_hash": "51be592ba9a59c8d66eb1bcc70c3d2b011c87c66128aff36574973b40389ad96", + "tp": 4 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.092, + "mns": 16, + "requests_sha256": "aa0482b10414d911af227e2df172c19ecca0add2e0024dc88f85ffbd063854bb", + "result_sha256": "91e2491de4ca0868b667e7d126b755f03bdd78378681b8070a2bbc0c38fb9055", + "trial_id": "cells/tp4_mns16/high-rep2/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "5d82b6885f5c654ae1ae126696df4bafe04f5be1c1109db24c7856b0456d9443", + "result_sha256": "6ed574c18723e265ab1327c5e43d3c76d37b3fc5711d06c77a51718e4ba16601", + "trial_id": "cells/tp4_mns64/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.07843137254901955, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.0784313725490196, + "tpot_max_over_slo": 0.05021820802747551, + "tpot_mean_over_slo": -0.012818677862446504, + "ttft_max_over_slo_max": -0.08022667251255673, + "ttft_mean_over_slo_max": -0.02098792773025101 + }, + "delta_state": { + "batch_size.mean": 0.32844164919636576, + "batch_tokens.mean": 20.103174603174637, + "decode_batch_size.mean": 0.3230008984725963, + "graph_full_share": 0.004542278127183774, + "graph_none_share": -0.017769791354697015, + "graph_padding_fraction": 0.006616409980351494, + "kv_usage_end_minus_start": 0.007401906100479305, + "kv_usage_max": 0.004352176770658023, + "kv_usage_mean": 0.0009581054950093242, + "preemptions": 0.0, + "prefill_token_fraction": 0.0019433062474734086, + "queue_running_mean": 0.822417270599999, + "queue_waiting_mean": -1.9255238218, + "scheduler_steps_per_s": 1.3999999999999915 + }, + "full_action_efficacy": 1, + "full_feasibility_transition": "false->true", + "group": { + "level": "high", + "offered_rate_per_gpu": 3.125, + "replicate": 3, + "request_hash": "604e338cf576d187157293922dada2bceb311567268ddae74eb7a089debf0242", + "tp": 4 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.14666666666666667, + "mns": 16, + "requests_sha256": "3a23ffbe0e724648226152ef5433cc5825ad640c37cf47997c2f091210eceeec", + "result_sha256": "136dde0451f806841ff3996b081fe0bffac0a76f60c3d78b7516f2689e106008", + "trial_id": "cells/tp4_mns16/high-rep3/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "5c5861d716181f06dc3f951ae0d6ee479b1b61fc21ebf24541c5b45053fcc167", + "result_sha256": "35b8f0465f6b0c197f71b5ecaf4e771e6613f86998ae44f8701ab9e4e1e440b4", + "trial_id": "cells/tp4_mns64/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.0, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.0, + "tpot_max_over_slo": 0.03209297007177109, + "tpot_mean_over_slo": 0.00165350785497842, + "ttft_max_over_slo_max": -0.04185720401195188, + "ttft_mean_over_slo_max": -0.008807509172654063 + }, + "delta_state": { + "batch_size.mean": -1.1226839723743751, + "batch_tokens.mean": -34.76613479399856, + "decode_batch_size.mean": -1.1063943796141942, + "graph_full_share": 0.012598237675637058, + "graph_none_share": -0.01938556799237913, + "graph_padding_fraction": -9.478587342680138e-05, + "kv_usage_end_minus_start": 3.947117882996398e-05, + "kv_usage_max": 0.004831301652910902, + "kv_usage_mean": 1.4883144002681564e-05, + "preemptions": 0.0, + "prefill_token_fraction": -0.00096100288388834, + "queue_running_mean": -0.07484160059999923, + "queue_waiting_mean": -0.1708327272, + "scheduler_steps_per_s": 12.400000000000006 + }, + "full_action_efficacy": 1, + "full_feasibility_transition": "false->true", + "group": { + "level": "low", + "offered_rate_per_gpu": 2.125, + "replicate": 1, + "request_hash": "6fb170f366b68a4e4e0fc976d370cb1f5b7b915d4dc22ebe5db3c6b9615afe68", + "tp": 4 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.6196078431372549, + "mns": 16, + "requests_sha256": "d7eaaefd35cc906f759dcaa7ac3c8543249a1a02f28572bec953e41e4379a29f", + "result_sha256": "11d9ec9d2a3358aed988f7b4b1014af087d61c4b5a72eb9076ae19bb5cc481cd", + "trial_id": "cells/tp4_mns16/low-rep1/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "931d372ded1e3aaa9c67f06653fac8f79b4ee4f369028c1148163580386681ce", + "result_sha256": "325ce57f33133670a6761b5dffb831ed3b2f464755ff743b56976b4a974c1215", + "trial_id": "cells/tp4_mns64/low-rep1/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.10869565217391303, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.10869565217391308, + "tpot_max_over_slo": 0.031286743469536304, + "tpot_mean_over_slo": -0.024426390991776098, + "ttft_max_over_slo_max": -0.014295891169846676, + "ttft_mean_over_slo_max": -0.003572963410477855 + }, + "delta_state": { + "batch_size.mean": 0.7171517639433311, + "batch_tokens.mean": 19.4169881786475, + "decode_batch_size.mean": 0.701919812339888, + "graph_full_share": 0.004382851322571657, + "graph_none_share": -0.007268742862434022, + "graph_padding_fraction": 0.002283307241934776, + "kv_usage_end_minus_start": 0.008891646331802172, + "kv_usage_max": 0.0030741209471074615, + "kv_usage_mean": 0.0003701503920676315, + "preemptions": 0.0, + "prefill_token_fraction": 0.00017846155000900144, + "queue_running_mean": 0.8948316157999994, + "queue_waiting_mean": -1.1446055668, + "scheduler_steps_per_s": -0.8000000000000114 + }, + "full_action_efficacy": 1, + "full_feasibility_transition": "false->true", + "group": { + "level": "low", + "offered_rate_per_gpu": 2.125, + "replicate": 2, + "request_hash": "eb4c0445556d23d73d27d728b45e63fec44e17e84a4f2f341787108b7f7a4901", + "tp": 4 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.6803921568627451, + "mns": 16, + "requests_sha256": "7fdb90f679bba1747fbacc92fac2045c820e09965c755b20f6dafd4fd9e26a7a", + "result_sha256": "800e2aa6e9f9efef4be12ee778be6817364914d63ae0624775d02729089768d6", + "trial_id": "cells/tp4_mns16/low-rep2/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "72c8f70a240f79edcaa4eb0a2fe9bade8ac07093339c5b2d09c49ddd1cf27d16", + "result_sha256": "ff8b2283d02d5967893ca6225b561ae11011da6149d1f6cff7b4275c00170e1d", + "trial_id": "cells/tp4_mns64/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": 0.0, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.06666666666666676, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.06666666666666665, + "tpot_max_over_slo": -0.0004955744884145297, + "tpot_mean_over_slo": -0.0060310517702504285, + "ttft_max_over_slo_max": 0.0002604483355147097, + "ttft_mean_over_slo_max": -0.003228990856401895 + }, + "delta_state": { + "batch_size.mean": -0.09294265910522981, + "batch_tokens.mean": -6.586326402016368, + "decode_batch_size.mean": -0.0904221802142402, + "graph_full_share": 0.0001575299306868505, + "graph_none_share": -0.0036231884057971037, + "graph_padding_fraction": 0.0004465429838699502, + "kv_usage_end_minus_start": -0.002635620484154888, + "kv_usage_max": 0.0003123116904728551, + "kv_usage_mean": -0.00022787683290566817, + "preemptions": 0.0, + "prefill_token_fraction": -0.0009035229748303175, + "queue_running_mean": -0.21642387019999987, + "queue_waiting_mean": -0.0184107002, + "scheduler_steps_per_s": 4.6000000000000085 + }, + "full_action_efficacy": 1, + "full_feasibility_transition": "false->true", + "group": { + "level": "low", + "offered_rate_per_gpu": 2.125, + "replicate": 3, + "request_hash": "a660c44d1f8b9c0ada5a19285fa579871bcfcae7c6fa71649546efda9aa3baef", + "tp": 4 + }, + "kind": "matched_mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.6294117647058823, + "mns": 16, + "requests_sha256": "b592fe254476957265fc9139aefdea77be4b5540f3c1b8a429c10ea6ccab9a6a", + "result_sha256": "cc1b1f7f5280c2892d0c6deac9df9f34ce126b0284e6ad893ffbf0ddbf27969f", + "trial_id": "cells/tp4_mns16/low-rep3/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "requests_sha256": "8b2c779d2097c5e4038e94e1ac9b986e29f55d9acfd67eeb366c4e0e9270f6e0", + "result_sha256": "f026b69356701894fab184e0f2f7504a30b537982e823373899c9ab123a33891", + "trial_id": "cells/tp4_mns64/low-rep3/result.json" + } + } + ], + "efficacy": { + "feasibility_transitions": { + "false->false": 3, + "false->true": 6, + "true->true": 3 + }, + "minimum_balanced_accuracy": 0.75, + "minimum_delta_over_best_outcome": 0.15, + "outcome_delta": { + "best_accuracy": 0.8333333333333334, + "best_balanced_accuracy": 0.8333333333333334, + "best_feature": "tpot_max_over_slo", + "features": { + "admitted_fraction": { + "accuracy": 0.5, + "balanced_accuracy": 0.5, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + } + ] + }, + "admitted_input_tokens_mean_over_limit": { + "accuracy": 0.5, + "balanced_accuracy": 0.5, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + } + ] + }, + "completed_fail_fraction_of_total": { + "accuracy": 0.5, + "balanced_accuracy": 0.5, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + } + ] + }, + "completed_over_admitted": { + "accuracy": 0.5833333333333334, + "balanced_accuracy": 0.5833333333333333, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": 0.03333333333333338, + "train_balanced_accuracy": 0.625 + }, + { + "direction": -1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": -0.039215686274509776, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": -0.05434782608695651, + "train_balanced_accuracy": 0.625 + } + ] + }, + "completed_pass_rate": { + "accuracy": 0.5833333333333334, + "balanced_accuracy": 0.5833333333333334, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": -0.5, + "train_balanced_accuracy": 0.625 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 1, + 1, + 1 + ], + "threshold": 0.0, + "train_balanced_accuracy": 0.5 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": -0.5, + "train_balanced_accuracy": 0.625 + } + ] + }, + "outstanding_over_admitted": { + "accuracy": 0.5833333333333334, + "balanced_accuracy": 0.5833333333333333, + "folds": [ + { + "direction": -1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": -0.033333333333333326, + "train_balanced_accuracy": 0.625 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.0392156862745098, + "train_balanced_accuracy": 0.75 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": 0.05434782608695654, + "train_balanced_accuracy": 0.625 + } + ] + }, + "tpot_max_over_slo": { + "accuracy": 0.8333333333333334, + "balanced_accuracy": 0.8333333333333334, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 1 + ], + "threshold": -0.000601708027350864, + "train_balanced_accuracy": 0.875 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 1, + 1, + 1 + ], + "threshold": -0.000601708027350864, + "train_balanced_accuracy": 1.0 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": 0.01522073488752175, + "train_balanced_accuracy": 0.875 + } + ] + }, + "tpot_mean_over_slo": { + "accuracy": 0.4166666666666667, + "balanced_accuracy": 0.41666666666666663, + "folds": [ + { + "direction": -1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 1, + 0, + 0 + ], + "threshold": -0.00409086687448007, + "train_balanced_accuracy": 0.75 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 1, + 1, + 0 + ], + "threshold": 0.0005373204891045424, + "train_balanced_accuracy": 0.75 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": -0.00025864649243734217, + "train_balanced_accuracy": 0.75 + } + ] + }, + "ttft_max_over_slo_max": { + "accuracy": 0.5, + "balanced_accuracy": 0.5, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": 0.00010340366861782274, + "train_balanced_accuracy": 0.625 + }, + { + "direction": -1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 0 + ], + "threshold": -0.021249613758603417, + "train_balanced_accuracy": 0.875 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": -0.0074689573375508155, + "train_balanced_accuracy": 0.75 + } + ] + }, + "ttft_mean_over_slo_max": { + "accuracy": 0.8333333333333334, + "balanced_accuracy": 0.8333333333333333, + "folds": [ + { + "direction": -1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 1 + ], + "threshold": -0.0017545182029157468, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": -0.002461917427018732, + "train_balanced_accuracy": 1.0 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 1 + ], + "threshold": -0.002633903704056712, + "train_balanced_accuracy": 0.75 + } + ] + } + }, + "labels": { + "distinct_n": 2, + "max": 1.0, + "min": 0.0, + "n": 12 + }, + "negative": 6, + "positive": 6 + }, + "telemetry_delta": { + "best_accuracy": 0.75, + "best_balanced_accuracy": 0.75, + "best_feature": "queue_waiting_mean", + "features": { + "decode_batch_size.mean": { + "accuracy": 0.5833333333333334, + "balanced_accuracy": 0.5833333333333334, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": 0.18834846816001205, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": -0.0791818658254686, + "train_balanced_accuracy": 0.75 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": 0.3778079250936579, + "train_balanced_accuracy": 0.75 + } + ] + }, + "graph_padding_fraction": { + "accuracy": 0.25, + "balanced_accuracy": 0.25, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 0 + ], + "threshold": 0.0002232714919349751, + "train_balanced_accuracy": 0.625 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 0, + 1 + ], + "threshold": 0.0019846847222085755, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 0, + 1 + ], + "threshold": 0.0027543290922952377, + "train_balanced_accuracy": 0.75 + } + ] + }, + "kv_usage_mean": { + "accuracy": 0.5, + "balanced_accuracy": 0.5, + "folds": [ + { + "direction": -1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": -0.0001671950542467852, + "train_balanced_accuracy": 0.625 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 1.1506892998063185e-05, + "train_balanced_accuracy": 0.875 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 1, + 1, + 0 + ], + "threshold": -1.97861808390893e-05, + "train_balanced_accuracy": 0.75 + } + ] + }, + "prefill_token_fraction": { + "accuracy": 0.5, + "balanced_accuracy": 0.5, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": 0.0019163391379847794, + "train_balanced_accuracy": 0.75 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 0 + ], + "threshold": 0.000955475284225904, + "train_balanced_accuracy": 0.75 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": 0.005609343341403783, + "train_balanced_accuracy": 0.75 + } + ] + }, + "queue_running_mean": { + "accuracy": 0.6666666666666666, + "balanced_accuracy": 0.6666666666666666, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": 0.7321133686999994, + "train_balanced_accuracy": 0.75 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": 0.40993477099999953, + "train_balanced_accuracy": 0.75 + }, + { + "direction": 1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": 0.7683205412999996, + "train_balanced_accuracy": 0.75 + } + ] + }, + "queue_waiting_mean": { + "accuracy": 0.75, + "balanced_accuracy": 0.75, + "folds": [ + { + "direction": -1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 1 + ], + "threshold": -0.0092053501, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 1, + 1 + ], + "threshold": -0.0092053501, + "train_balanced_accuracy": 1.0 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 1, + 0 + ], + "threshold": -0.0854163636, + "train_balanced_accuracy": 0.75 + } + ] + }, + "scheduler_steps_per_s": { + "accuracy": 0.4166666666666667, + "balanced_accuracy": 0.41666666666666663, + "folds": [ + { + "direction": 1, + "held_out_replicate": 1, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 1, + 1, + 0, + 1 + ], + "threshold": 0.9999999999999929, + "train_balanced_accuracy": 0.75 + }, + { + "direction": 1, + "held_out_replicate": 2, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": 4.300000000000004, + "train_balanced_accuracy": 0.75 + }, + { + "direction": -1, + "held_out_replicate": 3, + "test_labels": [ + 0, + 0, + 1, + 1 + ], + "test_predictions": [ + 0, + 0, + 0, + 0 + ], + "threshold": -16.9, + "train_balanced_accuracy": 0.75 + } + ] + } + }, + "labels": { + "distinct_n": 2, + "max": 1.0, + "min": 0.0, + "n": 12 + }, + "negative": 6, + "positive": 6 + }, + "telemetry_qualifying_features": [] + }, + "horizon_s": 5.0, + "qualifying_response_features": [], + "repeats": [ + { + "delta_outcome": { + "admitted_fraction": 0.027932960893854754, + "admitted_input_tokens_mean_over_limit": 0.25888824462890625, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.8181818181818182, + "completed_pass_rate": -1.0, + "outstanding_over_admitted": 0.8181818181818181, + "tpot_max_over_slo": -0.22724595748614082, + "tpot_mean_over_slo": -0.16274999088627282, + "ttft_max_over_slo_max": -0.034610742829196774, + "ttft_mean_over_slo_max": -0.0228428806456375 + }, + "delta_state": { + "batch_size.mean": 5.528833410386808, + "batch_tokens.mean": 384.9526121128063, + "decode_batch_size.mean": 5.423208506703652, + "graph_full_share": -0.09768839574664823, + "graph_none_share": 0.09557713052858684, + "graph_padding_fraction": -0.01691520035196146, + "kv_usage_end_minus_start": 0.16350284743730636, + "kv_usage_max": 0.1339294634828655, + "kv_usage_mean": 0.07938311082464784, + "preemptions": 0.0, + "prefill_token_fraction": 0.07360971724683552, + "queue_running_mean": 5.2693423148, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -77.8 + }, + "group": { + "cell": "tp1_mns64", + "level": "high", + "mns": 64, + "source_replicate": 1, + "target_replicate": 2, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "e970dcac20144cb1e13a35997377f6695a9c57d788a88bad7f18cf6c64e35cec", + "result_sha256": "3233686b60b920dcd6cc2f45193a81f3af2d46f781ef42c4d117630612084feb", + "trial_id": "cells/tp1_mns64/high-rep1/result.json" + }, + "target": { + "requests_sha256": "ec06878e2aefdc4853d972197cedc29ab94df7147abb2701e0d88b5dabf29728", + "result_sha256": "8215477a014f061c55e94d879a25bbf1676ee2ef1c5e81efadd23d20d337e07a", + "trial_id": "cells/tp1_mns64/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.011173184357541902, + "admitted_input_tokens_mean_over_limit": -0.18295179094587052, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.5, + "completed_pass_rate": 1.0, + "outstanding_over_admitted": -0.5, + "tpot_max_over_slo": 0.16581994141305348, + "tpot_mean_over_slo": 0.14577003201512728, + "ttft_max_over_slo_max": 0.04351074216538109, + "ttft_mean_over_slo_max": 0.02181711295270361 + }, + "delta_state": { + "batch_size.mean": -5.595011337868481, + "batch_tokens.mean": -365.5517006802721, + "decode_batch_size.mean": -5.494557823129252, + "graph_full_share": 0.09251700680272112, + "graph_none_share": -0.08866213151927438, + "graph_padding_fraction": 0.004841272439424705, + "kv_usage_end_minus_start": -0.1340793286042561, + "kv_usage_max": -0.12953341992207013, + "kv_usage_mean": -0.0768057629061545, + "preemptions": 0.0, + "prefill_token_fraction": -0.033037405519596885, + "queue_running_mean": -4.789778502000001, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 72.8 + }, + "group": { + "cell": "tp1_mns64", + "level": "high", + "mns": 64, + "source_replicate": 2, + "target_replicate": 3, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "ec06878e2aefdc4853d972197cedc29ab94df7147abb2701e0d88b5dabf29728", + "result_sha256": "8215477a014f061c55e94d879a25bbf1676ee2ef1c5e81efadd23d20d337e07a", + "trial_id": "cells/tp1_mns64/high-rep2/result.json" + }, + "target": { + "requests_sha256": "18d72d1fe16136359e28a1909e395ffd553dbe3edd2c0fd93a9cc270a5ec6d60", + "result_sha256": "480a3b50acaf9b9c1902e2669cf3aa7723a6703a00778da269b5b9757990ceef", + "trial_id": "cells/tp1_mns64/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.02459016393442623, + "admitted_input_tokens_mean_over_limit": 0.20505746694711535, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.4692307692307692, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.4692307692307693, + "tpot_max_over_slo": 0.38761381102051196, + "tpot_mean_over_slo": 0.33823327695869493, + "ttft_max_over_slo_max": -0.043946471996605396, + "ttft_mean_over_slo_max": -0.0057849611233298966 + }, + "delta_state": { + "batch_size.mean": 3.1123123406666036, + "batch_tokens.mean": 225.4005759607214, + "decode_batch_size.mean": 3.0546690586346896, + "graph_full_share": -0.04640732697573413, + "graph_none_share": 0.041473892927957695, + "graph_padding_fraction": 0.005316401000291102, + "kv_usage_end_minus_start": 0.11649515436107505, + "kv_usage_max": 0.10080927165551001, + "kv_usage_mean": 0.05787529741227895, + "preemptions": 0.0, + "prefill_token_fraction": 0.025873876159429043, + "queue_running_mean": 4.3325417076, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -59.6 + }, + "group": { + "cell": "tp1_mns64", + "level": "low", + "mns": 64, + "source_replicate": 1, + "target_replicate": 2, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "44d729c1ace9b09fe2ea4c4e110bd0f95fee69f83edc78ee0f65256922dcd2c2", + "result_sha256": "d2c08e71c5d4e0dd99662bab8457bd1ad0a4aba6bda57794dbfce62e36720f62", + "trial_id": "cells/tp1_mns64/low-rep1/result.json" + }, + "target": { + "requests_sha256": "97de3cced64fd88a5c2dcd087ca6c29d8b09a0a43d7bf0e4e844ef246462465b", + "result_sha256": "f194db2f7abb995171cd24626e4e515c000481f81283c929b9a5b63f110f1506", + "trial_id": "cells/tp1_mns64/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.06557377049180327, + "admitted_input_tokens_mean_over_limit": 0.058956204927884615, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.3692307692307692, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.36923076923076925, + "tpot_max_over_slo": -0.41323108928586083, + "tpot_mean_over_slo": -0.3718732634627717, + "ttft_max_over_slo_max": 0.05646172333702755, + "ttft_mean_over_slo_max": 0.02716241966764857 + }, + "delta_state": { + "batch_size.mean": -3.6161048689138573, + "batch_tokens.mean": -189.70786516853934, + "decode_batch_size.mean": -3.556179775280899, + "graph_full_share": 0.048689138576779034, + "graph_none_share": -0.037453183520599245, + "graph_padding_fraction": -0.008781536045622663, + "kv_usage_end_minus_start": -0.11025077430312713, + "kv_usage_max": -0.10765311219902085, + "kv_usage_mean": -0.06249167924800681, + "preemptions": 0.0, + "prefill_token_fraction": 0.00031032253091034523, + "queue_running_mean": -5.3659050614, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 17.799999999999997 + }, + "group": { + "cell": "tp1_mns64", + "level": "low", + "mns": 64, + "source_replicate": 2, + "target_replicate": 3, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "97de3cced64fd88a5c2dcd087ca6c29d8b09a0a43d7bf0e4e844ef246462465b", + "result_sha256": "f194db2f7abb995171cd24626e4e515c000481f81283c929b9a5b63f110f1506", + "trial_id": "cells/tp1_mns64/low-rep2/result.json" + }, + "target": { + "requests_sha256": "30f4623100c58580cfa4efe9a1998c63581c8e44511c556ef39cf5bd777883bf", + "result_sha256": "0be457aa2fc9ce95bdb92a6eb25544f5f61a9739932ee5afa40535d26456e348", + "trial_id": "cells/tp1_mns64/low-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.027932960893854754, + "admitted_input_tokens_mean_over_limit": 0.25888824462890625, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.44318181818181823, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.4431818181818182, + "tpot_max_over_slo": 0.3347538302351874, + "tpot_mean_over_slo": 0.33193704520196554, + "ttft_max_over_slo_max": 0.08130590917426161, + "ttft_mean_over_slo_max": 0.044041225448449114 + }, + "delta_state": { + "batch_size.mean": 3.494949494949495, + "batch_tokens.mean": 256.21313131313127, + "decode_batch_size.mean": 3.4393939393939394, + "graph_full_share": -0.05555555555555547, + "graph_none_share": 0.05555555555555555, + "graph_padding_fraction": -0.01983738870430219, + "kv_usage_end_minus_start": 0.07746654062391167, + "kv_usage_max": 0.09234290263197176, + "kv_usage_mean": 0.06554072058902435, + "preemptions": 0.0, + "prefill_token_fraction": 0.07077187634663484, + "queue_running_mean": 3.3297516184, + "queue_waiting_mean": 1.558876379, + "scheduler_steps_per_s": -63.0 + }, + "group": { + "cell": "tp1_mns8", + "level": "high", + "mns": 8, + "source_replicate": 1, + "target_replicate": 2, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "5f5bfa4a16846190f488d3369eed89ae895804145cea59197e6b544b703223fc", + "result_sha256": "f65e3dc91d17f5caab1f4aecf97d2c464b99f107231af2cfd96f5484880136ee", + "trial_id": "cells/tp1_mns8/high-rep1/result.json" + }, + "target": { + "requests_sha256": "e802d09057de349e5164c18314fcad09dc88c9673834fd6e5b100a57dd12fbf4", + "result_sha256": "4835a985dd6bb8dc50b53737baa980ac95a49e22f0b8a7326e1fb416c9b4e798", + "trial_id": "cells/tp1_mns8/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.011173184357541902, + "admitted_input_tokens_mean_over_limit": -0.18295179094587052, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.125, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.125, + "tpot_max_over_slo": -0.3936708804703955, + "tpot_mean_over_slo": -0.34893712293425444, + "ttft_max_over_slo_max": -0.07213344016539244, + "ttft_mean_over_slo_max": -0.04499520144345875 + }, + "delta_state": { + "batch_size.mean": -3.598494182067077, + "batch_tokens.mean": -226.33832991101983, + "decode_batch_size.mean": -3.5494638375541867, + "graph_full_share": 0.04903034451289068, + "graph_none_share": -0.04903034451289072, + "graph_padding_fraction": 0.006341404720607481, + "kv_usage_end_minus_start": -0.031145828150654364, + "kv_usage_max": -0.07099855714214642, + "kv_usage_mean": -0.06292620689574609, + "preemptions": 0.0, + "prefill_token_fraction": -0.021240192351919318, + "queue_running_mean": -2.8508891792, + "queue_waiting_mean": -1.558876379, + "scheduler_steps_per_s": 61.400000000000006 + }, + "group": { + "cell": "tp1_mns8", + "level": "high", + "mns": 8, + "source_replicate": 2, + "target_replicate": 3, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "e802d09057de349e5164c18314fcad09dc88c9673834fd6e5b100a57dd12fbf4", + "result_sha256": "4835a985dd6bb8dc50b53737baa980ac95a49e22f0b8a7326e1fb416c9b4e798", + "trial_id": "cells/tp1_mns8/high-rep2/result.json" + }, + "target": { + "requests_sha256": "cf1226185845cd8aa4e7ead0cb5c95c77eda62b84851a2ab579f984bbb88e8ac", + "result_sha256": "95d5103f2678eeb99c258870324566932e2f2853c3b6e0ee94bc6c538f6ed865", + "trial_id": "cells/tp1_mns8/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.02459016393442623, + "admitted_input_tokens_mean_over_limit": 0.20505746694711535, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.3153846153846153, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.31538461538461543, + "tpot_max_over_slo": 0.3275617000034563, + "tpot_mean_over_slo": 0.3065353005781929, + "ttft_max_over_slo_max": -0.008349240330668778, + "ttft_mean_over_slo_max": 0.008245060394983739 + }, + "delta_state": { + "batch_size.mean": 2.993173982992416, + "batch_tokens.mean": 207.01061824867847, + "decode_batch_size.mean": 2.9413238336014706, + "graph_full_share": -0.04658699149620771, + "graph_none_share": 0.04658699149620778, + "graph_padding_fraction": 0.0020584753487871725, + "kv_usage_end_minus_start": 0.08895964973381765, + "kv_usage_max": 0.08443206129658187, + "kv_usage_mean": 0.05291450133015573, + "preemptions": 0.0, + "prefill_token_fraction": 0.024494361846634782, + "queue_running_mean": 3.5259867252, + "queue_waiting_mean": 0.3949698864, + "scheduler_steps_per_s": -53.599999999999994 + }, + "group": { + "cell": "tp1_mns8", + "level": "low", + "mns": 8, + "source_replicate": 1, + "target_replicate": 2, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "0edc6095b16e5361a88b2765cc5d0f267ed16ff1d883e02fc3c58f57e59c1018", + "result_sha256": "8bc433109d148c21b7d158df95ec5d1fa4fa619243114563068e1e98c4241a29", + "trial_id": "cells/tp1_mns8/low-rep1/result.json" + }, + "target": { + "requests_sha256": "ca58a878401ac44cca0a9a595eab41659dafec2e923f7f2474e4f82ea30b2f3e", + "result_sha256": "42a56af136d1d3bdfc16d9cea092c2db0eaa4db2c85dceb21958c5e418122900", + "trial_id": "cells/tp1_mns8/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.06557377049180327, + "admitted_input_tokens_mean_over_limit": 0.058956204927884615, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.21538461538461534, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.2153846153846154, + "tpot_max_over_slo": -0.3717905500863392, + "tpot_mean_over_slo": -0.35676654521987006, + "ttft_max_over_slo_max": 0.02027610916411504, + "ttft_mean_over_slo_max": 0.01139487453555274 + }, + "delta_state": { + "batch_size.mean": -3.5556390977443613, + "batch_tokens.mean": -172.79774436090224, + "decode_batch_size.mean": -3.500751879699248, + "graph_full_share": 0.049624060150375904, + "graph_none_share": -0.049624060150375945, + "graph_padding_fraction": -0.00490937338166753, + "kv_usage_end_minus_start": -0.08274043484750482, + "kv_usage_max": -0.09124832081198064, + "kv_usage_mean": -0.057593469313557896, + "preemptions": 0.0, + "prefill_token_fraction": 0.0013579454633879662, + "queue_running_mean": -4.721547866, + "queue_waiting_mean": -0.3949698864, + "scheduler_steps_per_s": 15.200000000000003 + }, + "group": { + "cell": "tp1_mns8", + "level": "low", + "mns": 8, + "source_replicate": 2, + "target_replicate": 3, + "tp": 1 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "ca58a878401ac44cca0a9a595eab41659dafec2e923f7f2474e4f82ea30b2f3e", + "result_sha256": "42a56af136d1d3bdfc16d9cea092c2db0eaa4db2c85dceb21958c5e418122900", + "trial_id": "cells/tp1_mns8/low-rep2/result.json" + }, + "target": { + "requests_sha256": "8a72240f84bbeff9eabd63e7d1f7a4c19910660fc5e4335013a1deaf89408127", + "result_sha256": "0214f32cabbcdc1bad6c331c3945c505cad136fcc9a8336aeb6314b27474e279", + "trial_id": "cells/tp1_mns8/low-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.005797101449275366, + "admitted_input_tokens_mean_over_limit": 0.08894061053240737, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.4148148148148148, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.41481481481481475, + "tpot_max_over_slo": 0.18239212881473055, + "tpot_mean_over_slo": 0.22534509859074725, + "ttft_max_over_slo_max": 0.009043970329609387, + "ttft_mean_over_slo_max": 0.0034825192906686835 + }, + "delta_state": { + "batch_size.mean": 4.136376094514087, + "batch_tokens.mean": 294.2141424923907, + "decode_batch_size.mean": 4.035904389596526, + "graph_full_share": -0.08650808533964194, + "graph_none_share": 0.08037736393404786, + "graph_padding_fraction": -0.007242852466043042, + "kv_usage_end_minus_start": 0.03774188185038829, + "kv_usage_max": 0.02683241888245158, + "kv_usage_mean": 0.01589560565810534, + "preemptions": 0.0, + "prefill_token_fraction": 0.01670564225806337, + "queue_running_mean": 3.658735814, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -40.39999999999999 + }, + "group": { + "cell": "tp2_mns64", + "level": "high", + "mns": 64, + "source_replicate": 1, + "target_replicate": 2, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "19537ec05f1e40543d850964db12234561954c209d55cd8cd0a1da716ab105fc", + "result_sha256": "49523b3269db649aa70072058666da3309ecabb93242cd504b6413f5de0f5d54", + "trial_id": "cells/tp2_mns64/high-rep1/result.json" + }, + "target": { + "requests_sha256": "d95e0dcc3d3f25af11b4d3da0ca133f647fd602753b804337a7131cc56e03059", + "result_sha256": "f37a42d9ea734adcb24892f86cbb19e2c51cee0baf8a6a63c5d51c4820bd28f2", + "trial_id": "cells/tp2_mns64/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0, + "admitted_input_tokens_mean_over_limit": -0.07515914351851849, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.3333333333333333, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.3333333333333333, + "tpot_max_over_slo": -0.2056584360561972, + "tpot_mean_over_slo": -0.22610848720556842, + "ttft_max_over_slo_max": 0.0024637060026483013, + "ttft_mean_over_slo_max": -0.0009699875146560837 + }, + "delta_state": { + "batch_size.mean": -3.8698393491171377, + "batch_tokens.mean": -263.8179979938542, + "decode_batch_size.mean": -3.7790214466540357, + "graph_full_share": 0.0771251612081455, + "graph_none_share": -0.06919610871399684, + "graph_padding_fraction": 0.008047836044516822, + "kv_usage_end_minus_start": -0.028942690148230588, + "kv_usage_max": -0.029901904359948328, + "kv_usage_mean": -0.01598686261764442, + "preemptions": 0.0, + "prefill_token_fraction": -0.011907711608659222, + "queue_running_mean": -3.4762310214000003, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 33.2 + }, + "group": { + "cell": "tp2_mns64", + "level": "high", + "mns": 64, + "source_replicate": 2, + "target_replicate": 3, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "d95e0dcc3d3f25af11b4d3da0ca133f647fd602753b804337a7131cc56e03059", + "result_sha256": "f37a42d9ea734adcb24892f86cbb19e2c51cee0baf8a6a63c5d51c4820bd28f2", + "trial_id": "cells/tp2_mns64/high-rep2/result.json" + }, + "target": { + "requests_sha256": "ccba3d0a18a7db8501b040855bda473ee55c519619d4b9fa2a105bda06300829", + "result_sha256": "55447419925f30397d19863e149890241c58863d0adaafd511a67757905cb58e", + "trial_id": "cells/tp2_mns64/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.017021276595744678, + "admitted_input_tokens_mean_over_limit": 0.045296223958333326, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.33333333333333337, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.33333333333333337, + "tpot_max_over_slo": 0.22320900677050662, + "tpot_mean_over_slo": 0.15232562887487847, + "ttft_max_over_slo_max": 0.0061178085064360205, + "ttft_mean_over_slo_max": 0.018187332690771045 + }, + "delta_state": { + "batch_size.mean": 4.4320356115196375, + "batch_tokens.mean": 99.22318191879197, + "decode_batch_size.mean": 4.402188829591008, + "graph_full_share": -0.026162662010280058, + "graph_none_share": 0.02238508644647205, + "graph_padding_fraction": 0.010726240511491474, + "kv_usage_end_minus_start": -0.01923544232564689, + "kv_usage_max": 0.02004118226348972, + "kv_usage_mean": 0.014893345374172863, + "preemptions": 0.0, + "prefill_token_fraction": -0.00708953487763786, + "queue_running_mean": 4.799239215399999, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -38.400000000000006 + }, + "group": { + "cell": "tp2_mns64", + "level": "low", + "mns": 64, + "source_replicate": 1, + "target_replicate": 2, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "8685f475baf247f7ce52a6a2df1183cd77a6f580cd57a3a87c407b4e96c0895f", + "result_sha256": "7a8f4e462d496bd56b73b0a686653cbe499a238df62a8c9a50db687d051f1c68", + "trial_id": "cells/tp2_mns64/low-rep1/result.json" + }, + "target": { + "requests_sha256": "016a76ab3dc015700f9ecb9f60a20fcc3b456c45270472fdd1d04e84ebd7021a", + "result_sha256": "368869326f44a0032985eff9d3abfa2306b93c25370caa05cee255a8c0208c0e", + "trial_id": "cells/tp2_mns64/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.042553191489361694, + "admitted_input_tokens_mean_over_limit": -0.026056198846726164, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.11904761904761907, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.11904761904761904, + "tpot_max_over_slo": -0.2355341601559496, + "tpot_mean_over_slo": -0.1643432670810964, + "ttft_max_over_slo_max": -0.026516160830700145, + "ttft_mean_over_slo_max": -0.01345709933763525 + }, + "delta_state": { + "batch_size.mean": -5.32536868824603, + "batch_tokens.mean": -133.89198850405924, + "decode_batch_size.mean": -5.279523379974407, + "graph_full_share": 0.04036585621682853, + "graph_none_share": -0.034001132811680546, + "graph_padding_fraction": -0.008571843774165616, + "kv_usage_end_minus_start": 0.0019567969919042083, + "kv_usage_max": -0.028865953011293133, + "kv_usage_mean": -0.018137793999508895, + "preemptions": 0.0, + "prefill_token_fraction": 0.0041833878419771375, + "queue_running_mean": -6.512575867199999, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 57.599999999999994 + }, + "group": { + "cell": "tp2_mns64", + "level": "low", + "mns": 64, + "source_replicate": 2, + "target_replicate": 3, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "016a76ab3dc015700f9ecb9f60a20fcc3b456c45270472fdd1d04e84ebd7021a", + "result_sha256": "368869326f44a0032985eff9d3abfa2306b93c25370caa05cee255a8c0208c0e", + "trial_id": "cells/tp2_mns64/low-rep2/result.json" + }, + "target": { + "requests_sha256": "5455d1cdeabd6e2937130ed8fc8d86c1aaa6f04cbf26c3cb69ad064be5f67d73", + "result_sha256": "2de5c4524f57b487b94b4fdba35defc2a566236fc3e31f7260b7a9f85bb7007c", + "trial_id": "cells/tp2_mns64/low-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.005952380952380959, + "admitted_input_tokens_mean_over_limit": 0.11506300706129807, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.16666666666666663, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.16666666666666669, + "tpot_max_over_slo": 0.0634281492909402, + "tpot_mean_over_slo": 0.06688242088001703, + "ttft_max_over_slo_max": 0.13068378849614723, + "ttft_mean_over_slo_max": 0.05409936663613152 + }, + "delta_state": { + "batch_size.mean": 1.552585603284773, + "batch_tokens.mean": 89.12552429250253, + "decode_batch_size.mean": 1.5358014452458475, + "graph_full_share": -0.018898322943787682, + "graph_none_share": 0.01889832294378769, + "graph_padding_fraction": -0.003394579943621764, + "kv_usage_end_minus_start": 0.000535967229432166, + "kv_usage_max": 0.01052792772099076, + "kv_usage_mean": 0.006505251073294799, + "preemptions": 0.0, + "prefill_token_fraction": 0.010329730802724923, + "queue_running_mean": 0.5542123245999999, + "queue_waiting_mean": 2.0910913376, + "scheduler_steps_per_s": -32.39999999999999 + }, + "group": { + "cell": "tp2_mns8", + "level": "high", + "mns": 8, + "source_replicate": 1, + "target_replicate": 2, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "5d41a316f329e2efcc0f728cdd078377eb72fb9258738636db704bcfcca290aa", + "result_sha256": "466b3991190a232c984ba1b54fb6793cac1893dce196ee96f7238d70d49fcb74", + "trial_id": "cells/tp2_mns8/high-rep1/result.json" + }, + "target": { + "requests_sha256": "1b7d2cdcd639c00c443ae1b98287a7cc57323eb80c7f0e1bfc72f1ab5bf48760", + "result_sha256": "e9156d6871cc8cb3a20dce629cc2443df7473f3836b46eb0944d491ea5c4d44c", + "trial_id": "cells/tp2_mns8/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.0029761904761904795, + "admitted_input_tokens_mean_over_limit": -0.09617018479567307, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.14, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.14, + "tpot_max_over_slo": -0.07476021338613548, + "tpot_mean_over_slo": -0.06040260059613095, + "ttft_max_over_slo_max": -0.0990663813330078, + "ttft_mean_over_slo_max": -0.03931008928012512 + }, + "delta_state": { + "batch_size.mean": -1.5731600373589236, + "batch_tokens.mean": -75.68624207727024, + "decode_batch_size.mean": -1.5588509992086177, + "graph_full_share": 0.01874362795074891, + "graph_none_share": -0.018743627950748964, + "graph_padding_fraction": 0.004413545938114254, + "kv_usage_end_minus_start": 0.003471025866799371, + "kv_usage_max": -0.012199635031839073, + "kv_usage_mean": -0.007236177184589677, + "preemptions": 0.0, + "prefill_token_fraction": -0.006096255385559024, + "queue_running_mean": -0.43295287099999946, + "queue_waiting_mean": -1.9712983662, + "scheduler_steps_per_s": 28.0 + }, + "group": { + "cell": "tp2_mns8", + "level": "high", + "mns": 8, + "source_replicate": 2, + "target_replicate": 3, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "1b7d2cdcd639c00c443ae1b98287a7cc57323eb80c7f0e1bfc72f1ab5bf48760", + "result_sha256": "e9156d6871cc8cb3a20dce629cc2443df7473f3836b46eb0944d491ea5c4d44c", + "trial_id": "cells/tp2_mns8/high-rep2/result.json" + }, + "target": { + "requests_sha256": "5a68fda7c29477e5b3e66d70ad2b05b77be6c200cc1beea89d663a5729f31a2b", + "result_sha256": "f2116797b35057949acbf1f57898befac9ff18b94c808462f0969bdcf2446dd6", + "trial_id": "cells/tp2_mns8/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.017467248908296942, + "admitted_input_tokens_mean_over_limit": 0.045296223958333326, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.16666666666666663, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.16666666666666669, + "tpot_max_over_slo": 0.06375630676753702, + "tpot_mean_over_slo": 0.0900300343637355, + "ttft_max_over_slo_max": 0.051512272330001, + "ttft_mean_over_slo_max": 0.0365448741568495 + }, + "delta_state": { + "batch_size.mean": 3.2164733311475753, + "batch_tokens.mean": 83.75307177093255, + "decode_batch_size.mean": 3.188651751468882, + "graph_full_share": -0.027821579678693587, + "graph_none_share": 0.027821579678693545, + "graph_padding_fraction": -0.0015661122787500655, + "kv_usage_end_minus_start": -0.011063894950423037, + "kv_usage_max": 0.003075431006980267, + "kv_usage_mean": 0.009516064845812437, + "preemptions": 0.0, + "prefill_token_fraction": -0.003183579698054051, + "queue_running_mean": 2.5618635706, + "queue_waiting_mean": 1.0030269042, + "scheduler_steps_per_s": -25.60000000000001 + }, + "group": { + "cell": "tp2_mns8", + "level": "low", + "mns": 8, + "source_replicate": 1, + "target_replicate": 2, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "455a1c21388700f0e3234c49d15ba3b0426b0d3b551c096b297793afa0d4602f", + "result_sha256": "13de25a73cc8c752245f169cfca1d64220f697c15b835a646ba969a1005047fb", + "trial_id": "cells/tp2_mns8/low-rep1/result.json" + }, + "target": { + "requests_sha256": "cae4b764ebb8714a6f5d2009bb79497420b388986a992c51410f1681810c14c6", + "result_sha256": "92f92a576e990946c4767a2107d2ce0e6ba1b066337911399360c199fae3f5e4", + "trial_id": "cells/tp2_mns8/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.04803493449781659, + "admitted_input_tokens_mean_over_limit": -0.009297688802083315, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.10256410256410264, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.10256410256410253, + "tpot_max_over_slo": -0.07959600126436789, + "tpot_mean_over_slo": -0.121404858913335, + "ttft_max_over_slo_max": -0.07178450832725503, + "ttft_mean_over_slo_max": -0.03313614673934353 + }, + "delta_state": { + "batch_size.mean": -4.304456872572413, + "batch_tokens.mean": -123.40500688035755, + "decode_batch_size.mean": -4.261865986626437, + "graph_full_share": 0.04259088594597549, + "graph_none_share": -0.04259088594597552, + "graph_padding_fraction": 0.005238254196308781, + "kv_usage_end_minus_start": -0.0053979556678535046, + "kv_usage_max": -0.011102178323953882, + "kv_usage_mean": -0.01280541269135944, + "preemptions": 0.0, + "prefill_token_fraction": 0.000758348233463435, + "queue_running_mean": -4.5151126308, + "queue_waiting_mean": -1.010089547, + "scheduler_steps_per_s": 49.60000000000001 + }, + "group": { + "cell": "tp2_mns8", + "level": "low", + "mns": 8, + "source_replicate": 2, + "target_replicate": 3, + "tp": 2 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "cae4b764ebb8714a6f5d2009bb79497420b388986a992c51410f1681810c14c6", + "result_sha256": "92f92a576e990946c4767a2107d2ce0e6ba1b066337911399360c199fae3f5e4", + "trial_id": "cells/tp2_mns8/low-rep2/result.json" + }, + "target": { + "requests_sha256": "cc8c01e4560411cd5b84cdc9bebdda9a86b88615ee1c39a996affe669d26c167", + "result_sha256": "c9a7d026bd89cc027c45b8f1899d56e21d53d4234e95db365a9492f670a78d36", + "trial_id": "cells/tp2_mns8/low-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.0013333333333333391, + "admitted_input_tokens_mean_over_limit": 0.0868109341325431, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.025105868118572294, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.025105868118572294, + "tpot_max_over_slo": 0.029982028815044692, + "tpot_mean_over_slo": 0.05498080777948092, + "ttft_max_over_slo_max": 0.05707128983340226, + "ttft_mean_over_slo_max": 0.04147020173474 + }, + "delta_state": { + "batch_size.mean": 3.8799424686192463, + "batch_tokens.mean": 164.1232217573222, + "decode_batch_size.mean": 3.8344665271966534, + "graph_full_share": -0.04971234309623429, + "graph_none_share": 0.042429393305439336, + "graph_padding_fraction": -0.000239797608965738, + "kv_usage_end_minus_start": 0.003295296296107475, + "kv_usage_max": 0.004723598096277648, + "kv_usage_mean": 0.003950784826693938, + "preemptions": 0.0, + "prefill_token_fraction": 0.013157938495005683, + "queue_running_mean": 2.4192883438, + "queue_waiting_mean": 1.2621521842000005, + "scheduler_steps_per_s": -31.599999999999994 + }, + "group": { + "cell": "tp4_mns16", + "level": "high", + "mns": 16, + "source_replicate": 1, + "target_replicate": 2, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "8695422a0f1e0e1c097a08a7f4c082f1ba2e3bb26b58caadae0afc7438aeca90", + "result_sha256": "c54a2bb5c1b78bdef3fa09c39f5974215370d6fc7c2b6d403a3d376d53a1d9eb", + "trial_id": "cells/tp4_mns16/high-rep1/result.json" + }, + "target": { + "requests_sha256": "aa0482b10414d911af227e2df172c19ecca0add2e0024dc88f85ffbd063854bb", + "result_sha256": "91e2491de4ca0868b667e7d126b755f03bdd78378681b8070a2bbc0c38fb9055", + "trial_id": "cells/tp4_mns16/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.007999999999999993, + "admitted_input_tokens_mean_over_limit": -0.08157169117647056, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.1713106295149639, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.1713106295149639, + "tpot_max_over_slo": -0.04532225479511176, + "tpot_mean_over_slo": -0.04295654146532207, + "ttft_max_over_slo_max": -0.031098171496220545, + "ttft_mean_over_slo_max": -0.018361275960999665 + }, + "delta_state": { + "batch_size.mean": 0.28468665768194157, + "batch_tokens.mean": -55.978571428571456, + "decode_batch_size.mean": 0.2811657681940698, + "graph_full_share": 0.016324123989218342, + "graph_none_share": -0.006949123989218334, + "graph_padding_fraction": 0.0015473261462516127, + "kv_usage_end_minus_start": -0.0032850941403919087, + "kv_usage_max": -0.00460117222769163, + "kv_usage_mean": -0.0019998572533929705, + "preemptions": 0.0, + "prefill_token_fraction": -0.008209306549717632, + "queue_running_mean": 0.27542344140000097, + "queue_waiting_mean": -4.8449581018000005, + "scheduler_steps_per_s": 10.200000000000003 + }, + "group": { + "cell": "tp4_mns16", + "level": "high", + "mns": 16, + "source_replicate": 2, + "target_replicate": 3, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "aa0482b10414d911af227e2df172c19ecca0add2e0024dc88f85ffbd063854bb", + "result_sha256": "91e2491de4ca0868b667e7d126b755f03bdd78378681b8070a2bbc0c38fb9055", + "trial_id": "cells/tp4_mns16/high-rep2/result.json" + }, + "target": { + "requests_sha256": "3a23ffbe0e724648226152ef5433cc5825ad640c37cf47997c2f091210eceeec", + "result_sha256": "136dde0451f806841ff3996b081fe0bffac0a76f60c3d78b7516f2689e106008", + "trial_id": "cells/tp4_mns16/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0196078431372549, + "admitted_input_tokens_mean_over_limit": -0.009788771182442646, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.20048309178743962, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.20048309178743962, + "tpot_max_over_slo": 0.042659409131532156, + "tpot_mean_over_slo": 0.04424057361688544, + "ttft_max_over_slo_max": -0.048664552169308685, + "ttft_mean_over_slo_max": -0.015179490139230319 + }, + "delta_state": { + "batch_size.mean": 2.2298197150334396, + "batch_tokens.mean": 48.29412619947661, + "decode_batch_size.mean": 2.216560046525153, + "graph_full_share": -0.03405059610351846, + "graph_none_share": 0.02576330328583891, + "graph_padding_fraction": -0.0005586075805253821, + "kv_usage_end_minus_start": 0.005978463249284638, + "kv_usage_max": 0.005988665405000093, + "kv_usage_mean": 0.0033715964225947276, + "preemptions": 0.0, + "prefill_token_fraction": -0.0013328880320482295, + "queue_running_mean": 2.578025910000001, + "queue_waiting_mean": 0.9737728395999999, + "scheduler_steps_per_s": -3.5999999999999943 + }, + "group": { + "cell": "tp4_mns16", + "level": "low", + "mns": 16, + "source_replicate": 1, + "target_replicate": 2, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "d7eaaefd35cc906f759dcaa7ac3c8543249a1a02f28572bec953e41e4379a29f", + "result_sha256": "11d9ec9d2a3358aed988f7b4b1014af087d61c4b5a72eb9076ae19bb5cc481cd", + "trial_id": "cells/tp4_mns16/low-rep1/result.json" + }, + "target": { + "requests_sha256": "7fdb90f679bba1747fbacc92fac2045c820e09965c755b20f6dafd4fd9e26a7a", + "result_sha256": "800e2aa6e9f9efef4be12ee778be6817364914d63ae0624775d02729089768d6", + "trial_id": "cells/tp4_mns16/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.03137254901960784, + "admitted_input_tokens_mean_over_limit": 0.04353239639945655, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.17826086956521736, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.17826086956521742, + "tpot_max_over_slo": -0.06113145905583517, + "tpot_mean_over_slo": -0.07880983479690457, + "ttft_max_over_slo_max": 0.028715976329597957, + "ttft_mean_over_slo_max": 0.012690293574927458 + }, + "delta_state": { + "batch_size.mean": -5.802285141359179, + "batch_tokens.mean": -131.81382573186144, + "decode_batch_size.mean": -5.749516966234634, + "graph_full_share": 0.0604758274237851, + "graph_none_share": -0.055969252942589476, + "graph_padding_fraction": 0.00012825203851504416, + "kv_usage_end_minus_start": -0.0044583420476747015, + "kv_usage_max": -0.003932931028326259, + "kv_usage_mean": -0.00443657185283492, + "preemptions": 0.0, + "prefill_token_fraction": 0.003659185530759501, + "queue_running_mean": -4.786444050200001, + "queue_waiting_mean": -1.1252851525999998, + "scheduler_steps_per_s": 33.39999999999999 + }, + "group": { + "cell": "tp4_mns16", + "level": "low", + "mns": 16, + "source_replicate": 2, + "target_replicate": 3, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "7fdb90f679bba1747fbacc92fac2045c820e09965c755b20f6dafd4fd9e26a7a", + "result_sha256": "800e2aa6e9f9efef4be12ee778be6817364914d63ae0624775d02729089768d6", + "trial_id": "cells/tp4_mns16/low-rep2/result.json" + }, + "target": { + "requests_sha256": "b592fe254476957265fc9139aefdea77be4b5540f3c1b8a429c10ea6ccab9a6a", + "result_sha256": "cc1b1f7f5280c2892d0c6deac9df9f34ce126b0284e6ad893ffbf0ddbf27969f", + "trial_id": "cells/tp4_mns16/low-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.0013333333333333391, + "admitted_input_tokens_mean_over_limit": 0.0868109341325431, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.03781004234724741, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.0378100423472475, + "tpot_max_over_slo": 0.055603621890548405, + "tpot_mean_over_slo": 0.21675693493770581, + "ttft_max_over_slo_max": -0.008919246349250898, + "ttft_mean_over_slo_max": -0.0006546831702710018 + }, + "delta_state": { + "batch_size.mean": 9.968307375844843, + "batch_tokens.mean": 424.4382456655892, + "decode_batch_size.mean": 9.85935938877461, + "graph_full_share": -0.0783720246841022, + "graph_none_share": 0.06904202174551866, + "graph_padding_fraction": -0.0017060748565999734, + "kv_usage_end_minus_start": 0.010798462764978867, + "kv_usage_max": 0.010486722950182936, + "kv_usage_mean": 0.007244217838718085, + "preemptions": 0.0, + "prefill_token_fraction": 0.006436717740402331, + "queue_running_mean": 5.32519087, + "queue_waiting_mean": 0.041582113999999996, + "scheduler_steps_per_s": -25.400000000000006 + }, + "group": { + "cell": "tp4_mns64", + "level": "high", + "mns": 64, + "source_replicate": 1, + "target_replicate": 2, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "b4aeaf5b3175bd85fdac08a2ef657fb2278c6c4b36ea32ea417275ab6d55812d", + "result_sha256": "111a1042b614d05772888665a7cfbc86925b2fbeb52ffe19edb62a5bcfe2f513", + "trial_id": "cells/tp4_mns64/high-rep1/result.json" + }, + "target": { + "requests_sha256": "5d82b6885f5c654ae1ae126696df4bafe04f5be1c1109db24c7856b0456d9443", + "result_sha256": "6ed574c18723e265ab1327c5e43d3c76d37b3fc5711d06c77a51718e4ba16601", + "trial_id": "cells/tp4_mns64/high-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.007999999999999993, + "admitted_input_tokens_mean_over_limit": -0.08157169117647056, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.35603715170278644, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.3560371517027863, + "tpot_max_over_slo": -0.22825533543405396, + "tpot_mean_over_slo": -0.27698499834846063, + "ttft_max_over_slo_max": 0.06069803666711475, + "ttft_mean_over_slo_max": 0.020012810632276036 + }, + "delta_state": { + "batch_size.mean": -9.712633888243644, + "batch_tokens.mean": -497.54978706929927, + "decode_batch_size.mean": -9.560162601626017, + "graph_full_share": 0.10699445089688986, + "graph_none_share": -0.09583172022196412, + "graph_padding_fraction": 0.007385862591293114, + "kv_usage_end_minus_start": -0.026819845049980584, + "kv_usage_max": -0.026712524785870495, + "kv_usage_mean": -0.011639675385128475, + "preemptions": 0.0, + "prefill_token_fraction": -0.01559531495655564, + "queue_running_mean": -11.737911770200002, + "queue_waiting_mean": -0.0431090294, + "scheduler_steps_per_s": 34.599999999999994 + }, + "group": { + "cell": "tp4_mns64", + "level": "high", + "mns": 64, + "source_replicate": 2, + "target_replicate": 3, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "5d82b6885f5c654ae1ae126696df4bafe04f5be1c1109db24c7856b0456d9443", + "result_sha256": "6ed574c18723e265ab1327c5e43d3c76d37b3fc5711d06c77a51718e4ba16601", + "trial_id": "cells/tp4_mns64/high-rep2/result.json" + }, + "target": { + "requests_sha256": "5c5861d716181f06dc3f951ae0d6ee479b1b61fc21ebf24541c5b45053fcc167", + "result_sha256": "35b8f0465f6b0c197f71b5ecaf4e771e6613f86998ae44f8701ab9e4e1e440b4", + "trial_id": "cells/tp4_mns64/high-rep3/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": 0.0196078431372549, + "admitted_input_tokens_mean_over_limit": -0.009788771182442646, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": -0.30917874396135264, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": 0.3091787439613527, + "tpot_max_over_slo": 0.04185318252929737, + "tpot_mean_over_slo": 0.01816067477013092, + "ttft_max_over_slo_max": -0.021103239327203482, + "ttft_mean_over_slo_max": -0.00994494437705411 + }, + "delta_state": { + "batch_size.mean": 4.069655451351146, + "batch_tokens.mean": 102.47724917212267, + "decode_batch_size.mean": 4.024874238479235, + "graph_full_share": -0.04226598245658386, + "graph_none_share": 0.03788012841578402, + "graph_padding_fraction": 0.0018194855348361953, + "kv_usage_end_minus_start": 0.014830638402256846, + "kv_usage_max": 0.004231484699196653, + "kv_usage_mean": 0.0037268636706596775, + "preemptions": 0.0, + "prefill_token_fraction": -0.00019342359815088805, + "queue_running_mean": 3.5476991263999995, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -16.80000000000001 + }, + "group": { + "cell": "tp4_mns64", + "level": "low", + "mns": 64, + "source_replicate": 1, + "target_replicate": 2, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "931d372ded1e3aaa9c67f06653fac8f79b4ee4f369028c1148163580386681ce", + "result_sha256": "325ce57f33133670a6761b5dffb831ed3b2f464755ff743b56976b4a974c1215", + "trial_id": "cells/tp4_mns64/low-rep1/result.json" + }, + "target": { + "requests_sha256": "72c8f70a240f79edcaa4eb0a2fe9bade8ac07093339c5b2d09c49ddd1cf27d16", + "result_sha256": "ff8b2283d02d5967893ca6225b561ae11011da6149d1f6cff7b4275c00170e1d", + "trial_id": "cells/tp4_mns64/low-rep2/result.json" + } + }, + { + "delta_outcome": { + "admitted_fraction": -0.03137254901960784, + "admitted_input_tokens_mean_over_limit": 0.04353239639945655, + "completed_fail_fraction_of_total": 0.0, + "completed_over_admitted": 0.35362318840579715, + "completed_pass_rate": 0.0, + "outstanding_over_admitted": -0.35362318840579715, + "tpot_max_over_slo": -0.092913777013786, + "tpot_mean_over_slo": -0.060414495575378896, + "ttft_max_over_slo_max": 0.04327231583495934, + "ttft_mean_over_slo_max": 0.013034266129003418 + }, + "delta_state": { + "batch_size.mean": -6.61237956440774, + "batch_tokens.mean": -157.8171403125253, + "decode_batch_size.mean": -6.541858958788763, + "graph_full_share": 0.056250506031900294, + "graph_none_share": -0.05232369848595256, + "graph_padding_fraction": -0.0017085122195497817, + "kv_usage_end_minus_start": -0.01598560886363176, + "kv_usage_max": -0.006694740284960865, + "kv_usage_mean": -0.00503459907780822, + "preemptions": 0.0, + "prefill_token_fraction": 0.002577201005920182, + "queue_running_mean": -5.8976995362, + "queue_waiting_mean": 0.000909714, + "scheduler_steps_per_s": 38.80000000000001 + }, + "group": { + "cell": "tp4_mns64", + "level": "low", + "mns": 64, + "source_replicate": 2, + "target_replicate": 3, + "tp": 4 + }, + "kind": "same_config_workload_repeat", + "source": { + "requests_sha256": "72c8f70a240f79edcaa4eb0a2fe9bade8ac07093339c5b2d09c49ddd1cf27d16", + "result_sha256": "ff8b2283d02d5967893ca6225b561ae11011da6149d1f6cff7b4275c00170e1d", + "trial_id": "cells/tp4_mns64/low-rep2/result.json" + }, + "target": { + "requests_sha256": "8b2c779d2097c5e4038e94e1ac9b986e29f55d9acfd67eeb366c4e0e9270f6e0", + "result_sha256": "f026b69356701894fab184e0f2f7504a30b537982e823373899c9ab123a33891", + "trial_id": "cells/tp4_mns64/low-rep3/result.json" + } + } + ], + "response_statistics": { + "batch_size.mean": { + "action_above_repeat_p95_fraction": 0.08333333333333333, + "action_abs_median": 0.21069215415079778, + "action_delta": { + "distinct_n": 12, + "max": 10.325762195121952, + "min": -1.1226839723743751, + "n": 12 + }, + "action_signs": { + "consistency": 0.5, + "negative": 6, + "positive": 6, + "zero": 0 + }, + "effect_to_repeat_median": 0.054373699571412804, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 3.874890908868192, + "repeat_abs_p95": 9.247595739668252, + "repeat_delta": { + "distinct_n": 24, + "max": 9.968307375844843, + "min": -9.712633888243644, + "n": 24 + } + }, + "batch_tokens.mean": { + "action_above_repeat_p95_fraction": 0.08333333333333333, + "action_abs_median": 18.045513604403595, + "action_delta": { + "distinct_n": 12, + "max": 461.67439024390245, + "min": -34.76613479399856, + "n": 12 + }, + "action_signs": { + "consistency": 0.5, + "negative": 6, + "positive": 6, + "zero": 0 + }, + "effect_to_repeat_median": 0.10712015825142496, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 168.46048305911222, + "repeat_abs_p95": 418.5154006326717, + "repeat_delta": { + "distinct_n": 24, + "max": 424.4382456655892, + "min": -497.54978706929927, + "n": 24 + } + }, + "decode_batch_size.mean": { + "action_above_repeat_p95_fraction": 0.08333333333333333, + "action_abs_median": 0.20671153934341824, + "action_delta": { + "distinct_n": 12, + "max": 10.164329268292683, + "min": -1.1063943796141942, + "n": 12 + }, + "action_signs": { + "consistency": 0.5, + "negative": 6, + "positive": 6, + "zero": 0 + }, + "effect_to_repeat_median": 0.05430140299778245, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 3.8067439869253445, + "repeat_abs_p95": 9.107417055200422, + "repeat_delta": { + "distinct_n": 24, + "max": 9.85935938877461, + "min": -9.560162601626017, + "n": 24 + } + }, + "graph_full_share": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.003299836171280379, + "action_delta": { + "distinct_n": 12, + "max": 0.012598237675637058, + "min": -0.08612804878048774, + "n": 12 + }, + "action_signs": { + "consistency": 0.75, + "negative": 3, + "positive": 9, + "zero": 0 + }, + "effect_to_repeat_median": 0.06753691417406232, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.048859741544834856, + "repeat_abs_p95": 0.09691268740505915, + "repeat_delta": { + "distinct_n": 24, + "max": 0.10699445089688986, + "min": -0.09768839574664823, + "n": 24 + } + }, + "graph_none_share": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.00975501010655705, + "action_delta": { + "distinct_n": 12, + "max": 0.07111280487804877, + "min": -0.01938556799237913, + "n": 12 + }, + "action_signs": { + "consistency": 0.75, + "negative": 9, + "positive": 3, + "zero": 0 + }, + "effect_to_repeat_median": 0.21877645860951367, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.04458893872109165, + "repeat_abs_p95": 0.09453988067718995, + "repeat_delta": { + "distinct_n": 24, + "max": 0.09557713052858684, + "min": -0.09583172022196412, + "n": 24 + } + }, + "graph_padding_fraction": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.0012515460983914576, + "action_delta": { + "distinct_n": 12, + "max": 0.006616409980351494, + "min": -9.478587342680138e-05, + "n": 12 + }, + "action_signs": { + "consistency": 0.9090909090909091, + "negative": 1, + "positive": 10, + "zero": 1 + }, + "effect_to_repeat_median": 0.2567104007991265, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.004875322910546117, + "repeat_abs_p95": 0.015986856375890948, + "repeat_delta": { + "distinct_n": 24, + "max": 0.010726240511491474, + "min": -0.01983738870430219, + "n": 24 + } + }, + "kv_usage_end_minus_start": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.008146776216140739, + "action_delta": { + "distinct_n": 12, + "max": 0.08606331121732713, + "min": -0.01687018923627459, + "n": 12 + }, + "action_signs": { + "consistency": 0.8333333333333334, + "negative": 2, + "positive": 10, + "zero": 0 + }, + "effect_to_repeat_median": 0.4626083515997178, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.017610525594639326, + "repeat_abs_p95": 0.1314417024677789, + "repeat_delta": { + "distinct_n": 24, + "max": 0.16350284743730636, + "min": -0.1340793286042561, + "n": 24 + } + }, + "kv_usage_max": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.004591739211784462, + "action_delta": { + "distinct_n": 12, + "max": 0.04171319199456147, + "min": -0.01682167078536223, + "n": 12 + }, + "action_signs": { + "consistency": 0.9166666666666666, + "negative": 1, + "positive": 11, + "zero": 0 + }, + "effect_to_repeat_median": 0.19642246579235886, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.023376853524680108, + "repeat_abs_p95": 0.1262513737636127, + "repeat_delta": { + "distinct_n": 24, + "max": 0.1339294634828655, + "min": -0.12953341992207013, + "n": 24 + } + }, + "kv_usage_mean": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.0002990136124866498, + "action_delta": { + "distinct_n": 12, + "max": 0.01377304273482051, + "min": -0.00022787683290566817, + "n": 12 + }, + "action_signs": { + "consistency": 0.6666666666666666, + "negative": 4, + "positive": 8, + "zero": 0 + }, + "effect_to_repeat_median": 0.021590398513840623, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.013849379032766153, + "repeat_abs_p95": 0.07511600655858494, + "repeat_delta": { + "distinct_n": 24, + "max": 0.07938311082464784, + "min": -0.0768057629061545, + "n": 24 + } + }, + "preemptions": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.0, + "action_delta": { + "distinct_n": 1, + "max": 0.0, + "min": 0.0, + "n": 12 + }, + "action_signs": { + "consistency": 0.0, + "negative": 0, + "positive": 0, + "zero": 12 + }, + "effect_to_repeat_median": 0.0, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.0, + "repeat_abs_p95": 0.0, + "repeat_delta": { + "distinct_n": 1, + "max": 0.0, + "min": 0.0, + "n": 24 + } + }, + "prefill_token_fraction": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.0009881350686721802, + "action_delta": { + "distinct_n": 12, + "max": 0.016050535408914768, + "min": -0.009907841139181417, + "n": 12 + }, + "action_signs": { + "consistency": 0.5, + "negative": 6, + "positive": 6, + "zero": 0 + }, + "effect_to_repeat_median": 0.12917776465155323, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.007649420713677746, + "repeat_abs_p95": 0.06511170572257907, + "repeat_delta": { + "distinct_n": 24, + "max": 0.07360971724683552, + "min": -0.033037405519596885, + "n": 24 + } + }, + "queue_running_mean": { + "action_above_repeat_p95_fraction": 0.16666666666666666, + "action_abs_median": 0.42911666849999985, + "action_delta": { + "distinct_n": 12, + "max": 12.835752482200002, + "min": -0.21642387019999987, + "n": 12 + }, + "action_signs": { + "consistency": 0.5, + "negative": 6, + "positive": 6, + "zero": 0 + }, + "effect_to_repeat_median": 0.10739626232229334, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 3.9956387608, + "repeat_abs_p95": 6.420344417549997, + "repeat_delta": { + "distinct_n": 24, + "max": 5.32519087, + "min": -11.737911770200002, + "n": 24 + } + }, + "queue_waiting_mean": { + "action_above_repeat_p95_fraction": 0.16666666666666666, + "action_abs_median": 0.28290130680000003, + "action_delta": { + "distinct_n": 9, + "max": 0.0, + "min": -6.7273728942, + "n": 12 + }, + "action_signs": { + "consistency": 1.0, + "negative": 8, + "positive": 0, + "zero": 4 + }, + "effect_to_repeat_median": 1.2915540857901293, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.2190394579, + "repeat_abs_p95": 2.0731223918899997, + "repeat_delta": { + "distinct_n": 16, + "max": 2.0910913376, + "min": -4.8449581018000005, + "n": 24 + } + }, + "scheduler_steps_per_s": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 3.8000000000000043, + "action_delta": { + "distinct_n": 12, + "max": 12.400000000000006, + "min": -29.19999999999999, + "n": 12 + }, + "action_signs": { + "consistency": 0.5833333333333334, + "negative": 5, + "positive": 7, + "zero": 0 + }, + "effect_to_repeat_median": 0.11176470588235309, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 33.99999999999999, + "repeat_abs_p95": 71.32999999999997, + "repeat_delta": { + "distinct_n": 24, + "max": 72.8, + "min": -77.8, + "n": 24 + } + } + }, + "sanity": { + "action_pairs": 12, + "invariants": { + "efficacy_label_balance": true, + "expected_action_pair_count": true, + "expected_repeat_pair_count": true, + "finite_deltas": true, + "matched_action_request_hashes": true, + "probabilities_bounded": true + }, + "red_flags": [], + "repeat_pairs": 24, + "trials": 36 + } + } + }, + "provenance": { + "analysis_script": "/home/gahow/phd/aituner/runs/intervention-response-v0/analyze_p1.py", + "analysis_script_sha256": "902adcba58bcb73f97c455fdea3710f6cb28fa8d8f4ea5bc4915143ed106b17a", + "manifest": "/home/gahow/phd/replayserve/runs/fidelity_p1_frontier_committed_20260714/real/p1b/pilot-manifest.json", + "manifest_sha256": "86b249a087ab1bcd51cd8de3d1da6bf34afd41af977eb58c93229b941dbf5c8a", + "manifest_validation": { + "expected_trials": 36, + "matched_trials": 36, + "schema": "fidelity-prefix-pilot-manifest-v1" + }, + "phase6_v0_script_sha256": "f1b40c350f22e797b08b129df7b55386b407bd5ae7f466d36987e94d768ded2f", + "run_root": "/home/gahow/phd/replayserve/runs/fidelity_p1_frontier_committed_20260714/real/p1b", + "streams": [ + { + "bytes": 24501686, + "path": "/home/gahow/phd/replayserve/runs/fidelity_p1_frontier_committed_20260714/real/p1b/cells/tp1_mns64/opprof/opprof-v1-dp0-pid234511-1784005631788937266.jsonl", + "sha256": "a813076afe677e5c13010b2ec44f46998794ca44cdf30ee81be836e3623f0068" + }, + { + "bytes": 25524027, + "path": "/home/gahow/phd/replayserve/runs/fidelity_p1_frontier_committed_20260714/real/p1b/cells/tp1_mns8/opprof/opprof-v1-dp0-pid227734-1784005177936445360.jsonl", + "sha256": "1708759d2e77c42bff1940d43214fb2d927c3eebeda62d53a3fb7d04817e9b22" + }, + { + "bytes": 29431988, + "path": "/home/gahow/phd/replayserve/runs/fidelity_p1_frontier_committed_20260714/real/p1b/cells/tp2_mns64/opprof/opprof-v1-dp0-pid247791-1784006495467408663.jsonl", + "sha256": "65355de883f2eb5d31be161d82b26dddc53c41a0a35a0fdb807777bc5b21c5ec" + }, + { + "bytes": 26036993, + "path": "/home/gahow/phd/replayserve/runs/fidelity_p1_frontier_committed_20260714/real/p1b/cells/tp2_mns8/opprof/opprof-v1-dp0-pid241594-1784006096655191299.jsonl", + "sha256": "485e203d37d45fdd3c4de768b95da2050478f111f4d739b129d4f4ebd4737b70" + }, + { + "bytes": 17449143, + "path": "/home/gahow/phd/replayserve/runs/fidelity_p1_frontier_committed_20260714/real/p1b/cells/tp4_mns16/opprof/opprof-v1-dp0-pid256090-1784007028237607411.jsonl", + "sha256": "59e98014d01bfc68d9f97112ecd782cb03571ad437382ed67416c7b85ae48c56" + }, + { + "bytes": 22674678, + "path": "/home/gahow/phd/replayserve/runs/fidelity_p1_frontier_committed_20260714/real/p1b/cells/tp4_mns64/opprof/opprof-v1-dp0-pid262293-1784007376383569515.jsonl", + "sha256": "03e4f3cca3023a78e859b663703b9468dedf89e58320f0292e2973070e7616c8" + } + ] + }, + "sanity": { + "red_flags": [], + "stream_bytes": { + "distinct_n": 6, + "max": 29431988.0, + "min": 17449143.0, + "n": 6 + }, + "stream_count": 6 + }, + "schema": "intervention-response-p1-confirmation-v1", + "stable_incremental_efficacy_features": [], + "stable_response_features": [], + "status": "COMPLETE" +} diff --git a/runs/intervention-response-v0/phase6-audit.json b/runs/intervention-response-v0/phase6-audit.json new file mode 100644 index 0000000..6231482 --- /dev/null +++ b/runs/intervention-response-v0/phase6-audit.json @@ -0,0 +1,5121 @@ +{ + "claim_boundary": "Development-only identifiability gate. Passing opens a controlled real-GPU pilot; it does not establish tuning benefit or causality.", + "decision": "STOP_NO_IDENTIFIABLE_RESPONSE", + "frozen_gate": { + "expected_action_pairs": 17, + "gate_features": [ + "scheduler_steps_per_s", + "decode_batch_size.mean", + "prefill_token_fraction", + "queue_waiting_mean", + "queue_running_mean", + "kv_usage_mean", + "graph_padding_fraction" + ], + "horizons_s": [ + 5.0, + 10.0 + ], + "minimum_action_above_repeat_p95_fraction": 0.5, + "minimum_effect_to_repeat_median": 2.0, + "minimum_repeat_pairs": 20, + "minimum_sign_consistency": 0.75, + "minimum_stable_features": 2 + }, + "horizons": { + "10": { + "actions": [ + { + "delta_state": { + "batch_size.mean": 1.5764389277324504, + "batch_tokens.mean": 81.00995765564915, + "decode_batch_size.mean": 1.5631264281332364, + "graph_full_share": -0.011964790704335537, + "graph_none_share": 0.020610006604949223, + "graph_padding_fraction": -0.01937281246147585, + "kv_usage_end_minus_start": -0.02063938485088157, + "kv_usage_max": 0.05576515049492037, + "kv_usage_mean": 0.02372409715700479, + "preemptions": 0.0, + "prefill_token_fraction": 0.09894954087875252, + "queue_running_mean": 1.8681007873, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -51.89999999999999 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.24609375, + "request_hash": "7e48c6bfc00eeadd6011111170c31123fb117c9fa75c18ccc8d8d505fd7fcff3", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp1_mns16/anchor-0.24609375/result.json" + }, + "target": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.24609375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.003449406279594669, + "batch_tokens.mean": 0.2550229474757799, + "decode_batch_size.mean": 0.003361987324251192, + "graph_full_share": -8.37764988708134e-05, + "graph_none_share": -0.0012785022218984483, + "graph_padding_fraction": 0.00024814146059230855, + "kv_usage_end_minus_start": 4.607711554860394e-05, + "kv_usage_max": 0.00030157213266412963, + "kv_usage_mean": 0.0007577042092319561, + "preemptions": 0.0, + "prefill_token_fraction": 6.688650356756476e-05, + "queue_running_mean": 0.05724569279999958, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -0.20000000000000284 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.24609375, + "request_hash": "7e48c6bfc00eeadd6011111170c31123fb117c9fa75c18ccc8d8d505fd7fcff3", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.24609375/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp1_mns64/anchor-0.24609375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.012661422160780589, + "batch_tokens.mean": -0.39155502891061644, + "decode_batch_size.mean": -0.012529760925139577, + "graph_full_share": 0.0001261753508223773, + "graph_none_share": -0.0014757030161394735, + "graph_padding_fraction": 0.0004267789129811959, + "kv_usage_end_minus_start": 7.934839022727402e-06, + "kv_usage_max": 0.03040170172083234, + "kv_usage_mean": 0.0025619580859006993, + "preemptions": 0.0, + "prefill_token_fraction": -2.6753484588915022e-05, + "queue_running_mean": 0.22427197499999973, + "queue_waiting_mean": -0.0255129477, + "scheduler_steps_per_s": 0.29999999999999716 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.04195804195804198, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.25, + "request_hash": "26629995f38f2c013d5aa5e4b9d7344311ab1f951c9d83e68212c67ca8076fda", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.958041958041958, + "mns": 8, + "trial_id": "tp1_mns8/anchor-0.25/result.json" + }, + "target": { + "cell": "tp1_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp1_mns16/anchor-0.25/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.012870461691032453, + "batch_tokens.mean": -0.2637663627959057, + "decode_batch_size.mean": -0.01278327820794356, + "graph_full_share": 8.355083796041107e-05, + "graph_none_share": -0.002771708233208551, + "graph_padding_fraction": -4.1151267345866487e-05, + "kv_usage_end_minus_start": 1.7658454245395028e-05, + "kv_usage_max": 0.00011557359098801623, + "kv_usage_mean": -0.00031444354435781335, + "preemptions": 0.0, + "prefill_token_fraction": 2.6753484588915022e-05, + "queue_running_mean": -0.05587743330000006, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.20000000000000284 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.25, + "request_hash": "26629995f38f2c013d5aa5e4b9d7344311ab1f951c9d83e68212c67ca8076fda", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp1_mns16/anchor-0.25/result.json" + }, + "target": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.25/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.021751047667267098, + "batch_tokens.mean": 0.5249008791116694, + "decode_batch_size.mean": 0.021576208801315833, + "graph_full_share": -0.00016755391320344426, + "graph_none_share": -0.0012074809179768962, + "graph_padding_fraction": 9.628532857289349e-05, + "kv_usage_end_minus_start": 4.607711554860394e-05, + "kv_usage_max": 0.00030157213266412963, + "kv_usage_mean": 0.00019975354503918435, + "preemptions": 0.0, + "prefill_token_fraction": -1.337692842384719e-05, + "queue_running_mean": 0.0040136895999998146, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -0.3999999999999915 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.25, + "request_hash": "26629995f38f2c013d5aa5e4b9d7344311ab1f951c9d83e68212c67ca8076fda", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.25/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp1_mns64/anchor-0.25/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 6.1794369551023545, + "batch_tokens.mean": 175.96941851979875, + "decode_batch_size.mean": 6.118283596420478, + "graph_full_share": -0.05096593309521069, + "graph_none_share": 0.047163651726389366, + "graph_padding_fraction": 0.0032959117320311947, + "kv_usage_end_minus_start": 0.07533673225448412, + "kv_usage_max": 0.06162226941794913, + "kv_usage_mean": 0.056370734075687004, + "preemptions": 0.0, + "prefill_token_fraction": -0.0018186060572318308, + "queue_running_mean": 5.9180508831, + "queue_waiting_mean": -2.7288210595, + "scheduler_steps_per_s": -13.3 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.06521739130434782, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.5, + "request_hash": "3160017dbd8249f711eb115f1e72ddbb37eab3a3333a48762cc3104e94bd2f15", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.09057971014492754, + "mns": 8, + "trial_id": "tp1_mns8/anchor-0.5/result.json" + }, + "target": { + "cell": "tp1_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.15579710144927536, + "mns": 16, + "trial_id": "tp1_mns16/anchor-0.5/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 4.764302767707134, + "batch_tokens.mean": 277.81382085064996, + "decode_batch_size.mean": 4.6529755062339735, + "graph_full_share": -0.09344327526748608, + "graph_none_share": 0.0681757891944469, + "graph_padding_fraction": 0.000877004096309171, + "kv_usage_end_minus_start": 0.13999257948102506, + "kv_usage_max": 0.13096340508568438, + "kv_usage_mean": 0.05558263246404621, + "preemptions": 0.0, + "prefill_token_fraction": 0.006009982585939322, + "queue_running_mean": 6.513921786700001, + "queue_waiting_mean": -2.611976143, + "scheduler_steps_per_s": -9.100000000000001 + }, + "descriptive_full_outcome": { + "delta_pass_rate": -0.06521739130434782, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.5, + "request_hash": "3160017dbd8249f711eb115f1e72ddbb37eab3a3333a48762cc3104e94bd2f15", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.15579710144927536, + "mns": 16, + "trial_id": "tp1_mns16/anchor-0.5/result.json" + }, + "target": { + "cell": "tp1_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.09057971014492754, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.5/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.8274828140997492, + "batch_tokens.mean": 96.29113646336111, + "decode_batch_size.mean": -0.8609770367120078, + "graph_full_share": -0.017588123445955728, + "graph_none_share": 0.015211350007313162, + "graph_padding_fraction": 7.496352550239935e-05, + "kv_usage_end_minus_start": 0.03212970309780483, + "kv_usage_max": 0.01812081632758722, + "kv_usage_mean": 0.003998827610290162, + "preemptions": 0.0, + "prefill_token_fraction": 0.004183520933583096, + "queue_running_mean": 0.37492188330000076, + "queue_waiting_mean": -0.1123975519, + "scheduler_steps_per_s": -1.299999999999999 + }, + "descriptive_full_outcome": { + "delta_pass_rate": -0.02898550724637681, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.5, + "request_hash": "3160017dbd8249f711eb115f1e72ddbb37eab3a3333a48762cc3104e94bd2f15", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.09057971014492754, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.5/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.06159420289855073, + "mns": 64, + "trial_id": "tp1_mns64/anchor-0.5/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.07209087471218689, + "batch_tokens.mean": 0.5870128720027967, + "decode_batch_size.mean": 0.071372838111468, + "graph_full_share": -0.0007180366007190075, + "graph_none_share": 0.00017950915017974842, + "graph_padding_fraction": -0.00012257265767716408, + "kv_usage_end_minus_start": 0.0005957119907479269, + "kv_usage_max": 0.003445359565031225, + "kv_usage_mean": 0.0015147564690633879, + "preemptions": 0.0, + "prefill_token_fraction": 0.0006457635751305757, + "queue_running_mean": 0.2144143154, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -5.000000000000014 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.2421875, + "request_hash": "adb62bea7f7a12c1e33fa1572ec1d0e274100013ad90e14c6ef5c549b0e0d017", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.2421875/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp1_mns64/anchor-0.2421875/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.36245150019298356, + "batch_tokens.mean": -0.3978304588945094, + "decode_batch_size.mean": -0.35854104454872315, + "graph_full_share": 0.003837325045198847, + "graph_none_share": -0.010532837670384139, + "graph_padding_fraction": -0.04819081852048884, + "kv_usage_end_minus_start": -0.006582719323285691, + "kv_usage_max": -0.0005696857286345836, + "kv_usage_mean": -0.0009069497569939534, + "preemptions": 0.0, + "prefill_token_fraction": -0.0024232654720200003, + "queue_running_mean": -0.4996837289, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 21.599999999999994 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.4921875, + "request_hash": "cd227aee3be472a35e8c35af60a44a1411c4dc689cbd98746b3fb8a8d329b44c", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "mns_increase", + "source": { + "cell": "tp2_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "trial_id": "tp2_mns8/anchor-0.4921875/result.json" + }, + "target": { + "cell": "tp2_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp2_mns16/anchor-0.4921875/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.11406418543540475, + "batch_tokens.mean": 9.343502830968255, + "decode_batch_size.mean": -0.11416962019156696, + "graph_full_share": -0.0001054347561618707, + "graph_none_share": -0.006673028798106863, + "graph_padding_fraction": 0.00039894330767695045, + "kv_usage_end_minus_start": 0.013684335607858866, + "kv_usage_max": 0.015105694785835122, + "kv_usage_mean": 0.003178130879397629, + "preemptions": 0.0, + "prefill_token_fraction": 0.010932399371689994, + "queue_running_mean": 1.5075751790999998, + "queue_waiting_mean": -1.0976031745, + "scheduler_steps_per_s": 7.0 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.728937728937729, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.49609375, + "request_hash": "a78992ce59bb3b857a7ef8844e0a690ea9dd529a659cf5edd599b63fef8b6a80", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "mns_increase", + "source": { + "cell": "tp2_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.27106227106227104, + "mns": 8, + "trial_id": "tp2_mns8/anchor-0.49609375/result.json" + }, + "target": { + "cell": "tp2_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp2_mns16/anchor-0.49609375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 5.413566807825205, + "batch_tokens.mean": 200.71125302018655, + "decode_batch_size.mean": 5.3571681691824065, + "graph_full_share": -0.05071523213218676, + "graph_none_share": 0.05388272583201268, + "graph_padding_fraction": -0.227748799260124, + "kv_usage_end_minus_start": 0.0335338856501185, + "kv_usage_max": 0.060946820037647065, + "kv_usage_mean": 0.028804550592809862, + "preemptions": 0.0, + "prefill_token_fraction": 0.8741864436917179, + "queue_running_mean": 10.8362644165, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -89.4 + }, + "descriptive_full_outcome": { + "delta_pass_rate": -0.7698209718670077, + "feasibility_transition": "true->false" + }, + "group": { + "anchor": 0.75, + "request_hash": "4f4c792e90f5c1bf33978fea26debcadfce5f8b872a31be86a88a1bf6b09a21c", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "mns_increase", + "source": { + "cell": "tp2_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp2_mns32/anchor-0.75/result.json" + }, + "target": { + "cell": "tp2_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.23017902813299232, + "mns": 64, + "trial_id": "tp2_mns64/anchor-0.75/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 2.075957134599138, + "batch_tokens.mean": 46.93942520046838, + "decode_batch_size.mean": 2.0480560866794146, + "graph_full_share": -0.0074377102879925605, + "graph_none_share": -0.0018112558732417336, + "graph_padding_fraction": 0.0006496717251760695, + "kv_usage_end_minus_start": 0.018695600546584812, + "kv_usage_max": 0.017004326138624792, + "kv_usage_mean": 0.00908001267992682, + "preemptions": 0.0, + "prefill_token_fraction": 0.0002714485379902154, + "queue_running_mean": 8.942033995400001, + "queue_waiting_mean": -3.5751631934000008, + "scheduler_steps_per_s": -12.200000000000003 + }, + "descriptive_full_outcome": { + "delta_pass_rate": -0.032423208191126277, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.033717411016, + "request_hash": "472a874ecc0e844b5b36a715bbc309b63e73074d39327cd734869f76721d71db", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.06313993174061433, + "mns": 16, + "trial_id": "tp4_mns16/anchor-0.033717411016/result.json" + }, + "target": { + "cell": "tp4_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.030716723549488054, + "mns": 32, + "trial_id": "tp4_mns32/anchor-0.033717411016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.35039583066624225, + "batch_tokens.mean": 122.17784504581891, + "decode_batch_size.mean": -0.430057526564223, + "graph_full_share": -0.016886297279774087, + "graph_none_share": 0.014833841973330465, + "graph_padding_fraction": -0.0008982073370737251, + "kv_usage_end_minus_start": 0.023420994136330364, + "kv_usage_max": 0.017803055174036908, + "kv_usage_mean": 0.0044696216831996635, + "preemptions": 0.0, + "prefill_token_fraction": 0.015941265487523948, + "queue_running_mean": 5.9603496991, + "queue_waiting_mean": -5.3947101023999995, + "scheduler_steps_per_s": -6.0 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.08361774744027303, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.033717411016, + "request_hash": "472a874ecc0e844b5b36a715bbc309b63e73074d39327cd734869f76721d71db", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "mns_increase", + "source": { + "cell": "tp4_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.030716723549488054, + "mns": 32, + "trial_id": "tp4_mns32/anchor-0.033717411016/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.11433447098976109, + "mns": 64, + "trial_id": "tp4_mns64/anchor-0.033717411016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -1.3459024035954341, + "batch_tokens.mean": -76.90460019071148, + "decode_batch_size.mean": -1.335767993913132, + "graph_full_share": 0.014601482572194069, + "graph_none_share": -0.03533131042635292, + "graph_padding_fraction": 0.215661617603708, + "kv_usage_end_minus_start": -0.0019582245100192575, + "kv_usage_max": 0.004037693486432903, + "kv_usage_mean": -0.0013060500299530847, + "preemptions": 0.0, + "prefill_token_fraction": -0.7248107341009736, + "queue_running_mean": -1.1173600969999997, + "queue_waiting_mean": -5.5313452697, + "scheduler_steps_per_s": 55.0 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.8216666666666667, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.034252608017, + "request_hash": "21c1f3b7d972b19c952a894863a70d1e85bd0e24a7e7b6b0fcc088360d0e01bd", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "mns_increase", + "source": { + "cell": "tp4_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.17833333333333334, + "mns": 8, + "trial_id": "tp4_mns8/anchor-0.034252608017/result.json" + }, + "target": { + "cell": "tp4_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp4_mns16/anchor-0.034252608017/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.001077049918674966, + "batch_tokens.mean": -0.009036864794174093, + "decode_batch_size.mean": 0.0014499324412282633, + "graph_full_share": -0.0018530405936193484, + "graph_none_share": -0.0005575282018593251, + "graph_padding_fraction": -0.005954146779449193, + "kv_usage_end_minus_start": 2.5931683662605565e-05, + "kv_usage_max": 1.368725807104898e-05, + "kv_usage_mean": -2.4961532697604337e-05, + "preemptions": 0.0, + "prefill_token_fraction": -0.0012108546438647505, + "queue_running_mean": -0.027323256100000748, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 1.4000000000000057 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.034252608017, + "request_hash": "21c1f3b7d972b19c952a894863a70d1e85bd0e24a7e7b6b0fcc088360d0e01bd", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp4_mns16/anchor-0.034252608017/result.json" + }, + "target": { + "cell": "tp4_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp4_mns32/anchor-0.034252608017/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.012380697130775609, + "batch_tokens.mean": 0.015975045041020763, + "decode_batch_size.mean": 0.012248179747174959, + "graph_full_share": 0.0004243534193951737, + "graph_none_share": 2.977918732597739e-06, + "graph_padding_fraction": 0.0021324803565644923, + "kv_usage_end_minus_start": -4.493314282427718e-06, + "kv_usage_max": 1.9874666237429395e-05, + "kv_usage_mean": 2.2389395203431008e-05, + "preemptions": 0.0, + "prefill_token_fraction": 9.913223620203193e-05, + "queue_running_mean": 0.015902196000000757, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -0.5 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.034252608017, + "request_hash": "21c1f3b7d972b19c952a894863a70d1e85bd0e24a7e7b6b0fcc088360d0e01bd", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "mns_increase", + "source": { + "cell": "tp4_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp4_mns32/anchor-0.034252608017/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp4_mns64/anchor-0.034252608017/result.json" + } + } + ], + "descriptive_full_outcome": { + "delta_pass_rate": { + "distinct_n": 10, + "max": 0.8216666666666667, + "min": -0.7698209718670077, + "n": 17 + }, + "feasibility_transitions": { + "false->false": 5, + "false->true": 2, + "true->false": 1, + "true->true": 9 + }, + "limitation": "Full outcomes may use different elapsed durations when a trial early-stopped; they are descriptive and are not a gate input.", + "negative": 4, + "positive": 5, + "zero": 8 + }, + "feature_statistics": { + "batch_size.mean": { + "action_above_repeat_p95_fraction": 0.058823529411764705, + "action_abs_median": 0.35039583066624225, + "action_delta": { + "distinct_n": 17, + "max": 6.1794369551023545, + "min": -1.3459024035954341, + "n": 17 + }, + "action_signs": { + "consistency": 0.5882352941176471, + "negative": 7, + "positive": 10, + "zero": 0 + }, + "effect_to_repeat_median": 6.562183065127602, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.05339622914945741, + "repeat_abs_p95": 5.572276889098532, + "repeat_delta": { + "distinct_n": 29, + "max": 0.648283558063266, + "min": -5.684231334296602, + "n": 29 + } + }, + "batch_tokens.mean": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 9.343502830968255, + "action_delta": { + "distinct_n": 17, + "max": 277.81382085064996, + "min": -76.90460019071148, + "n": 17 + }, + "action_signs": { + "consistency": 0.7058823529411765, + "negative": 5, + "positive": 12, + "zero": 0 + }, + "effect_to_repeat_median": 8.491093823400865, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 1.1003885983709436, + "repeat_abs_p95": 315.3187671058407, + "repeat_delta": { + "distinct_n": 29, + "max": 49.961881401529, + "min": -364.45844383082266, + "n": 29 + } + }, + "decode_batch_size.mean": { + "action_above_repeat_p95_fraction": 0.058823529411764705, + "action_abs_median": 0.35854104454872315, + "action_delta": { + "distinct_n": 17, + "max": 6.118283596420478, + "min": -1.335767993913132, + "n": 17 + }, + "action_signs": { + "consistency": 0.5882352941176471, + "negative": 7, + "positive": 10, + "zero": 0 + }, + "effect_to_repeat_median": 6.76984750225626, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.05296146544353153, + "repeat_abs_p95": 5.508199821866692, + "repeat_delta": { + "distinct_n": 29, + "max": 0.6427639871873927, + "min": -5.614987163710968, + "n": 29 + } + }, + "graph_full_share": { + "action_above_repeat_p95_fraction": 0.058823529411764705, + "action_abs_median": 0.003837325045198847, + "action_delta": { + "distinct_n": 17, + "max": 0.014601482572194069, + "min": -0.09344327526748608, + "n": 17 + }, + "action_signs": { + "consistency": 0.7058823529411765, + "negative": 12, + "positive": 5, + "zero": 0 + }, + "effect_to_repeat_median": 4.142422601449927, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.0009263480369809951, + "repeat_abs_p95": 0.05226163287124676, + "repeat_delta": { + "distinct_n": 28, + "max": 0.055525557955363625, + "min": -0.006350826071218729, + "n": 29 + } + }, + "graph_none_share": { + "action_above_repeat_p95_fraction": 0.058823529411764705, + "action_abs_median": 0.006673028798106863, + "action_delta": { + "distinct_n": 17, + "max": 0.0681757891944469, + "min": -0.03533131042635292, + "n": 17 + }, + "action_signs": { + "consistency": 0.5294117647058824, + "negative": 9, + "positive": 8, + "zero": 0 + }, + "effect_to_repeat_median": 6.753166603769785, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.0009881332994778795, + "repeat_abs_p95": 0.0591340838533234, + "repeat_delta": { + "distinct_n": 22, + "max": 0.014663378024668453, + "min": -0.06263498920086392, + "n": 29 + } + }, + "graph_padding_fraction": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.000877004096309171, + "action_delta": { + "distinct_n": 17, + "max": 0.215661617603708, + "min": -0.227748799260124, + "n": 17 + }, + "action_signs": { + "consistency": 0.5882352941176471, + "negative": 7, + "positive": 10, + "zero": 0 + }, + "effect_to_repeat_median": 0.05354985977835987, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.016377336933075942, + "repeat_abs_p95": 0.24277823872412585, + "repeat_delta": { + "distinct_n": 29, + "max": 0.2448027632667215, + "min": -0.016377336933075942, + "n": 29 + } + }, + "kv_usage_end_minus_start": { + "action_above_repeat_p95_fraction": 0.11764705882352941, + "action_abs_median": 0.006582719323285691, + "action_delta": { + "distinct_n": 16, + "max": 0.13999257948102506, + "min": -0.02063938485088157, + "n": 17 + }, + "action_signs": { + "consistency": 0.7647058823529411, + "negative": 4, + "positive": 13, + "zero": 0 + }, + "effect_to_repeat_median": 322.61413699448417, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 2.0404311431021505e-05, + "repeat_abs_p95": 0.050972874042718504, + "repeat_delta": { + "distinct_n": 19, + "max": 0.004504676952132969, + "min": -0.07211360414777734, + "n": 29 + } + }, + "kv_usage_max": { + "action_above_repeat_p95_fraction": 0.23529411764705882, + "action_abs_median": 0.015105694785835122, + "action_delta": { + "distinct_n": 16, + "max": 0.13096340508568438, + "min": -0.0005696857286345836, + "n": 17 + }, + "action_signs": { + "consistency": 0.9411764705882353, + "negative": 1, + "positive": 16, + "zero": 0 + }, + "effect_to_repeat_median": 2958.616486447546, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 5.1056616682254585e-06, + "repeat_abs_p95": 0.051096537054163664, + "repeat_delta": { + "distinct_n": 16, + "max": 0.004527588437235774, + "min": -0.0609037076826664, + "n": 29 + } + }, + "kv_usage_mean": { + "action_above_repeat_p95_fraction": 0.17647058823529413, + "action_abs_median": 0.0025619580859006993, + "action_delta": { + "distinct_n": 17, + "max": 0.056370734075687004, + "min": -0.0013060500299530847, + "n": 17 + }, + "action_signs": { + "consistency": 0.7647058823529411, + "negative": 4, + "positive": 13, + "zero": 0 + }, + "effect_to_repeat_median": 7.0681027141206565, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.0003624675799889579, + "repeat_abs_p95": 0.026328182817430976, + "repeat_delta": { + "distinct_n": 29, + "max": 0.00522340215966962, + "min": -0.034746555150565066, + "n": 29 + } + }, + "preemptions": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.0, + "action_delta": { + "distinct_n": 1, + "max": 0.0, + "min": 0.0, + "n": 17 + }, + "action_signs": { + "consistency": 0.0, + "negative": 0, + "positive": 0, + "zero": 17 + }, + "effect_to_repeat_median": 0.0, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.0, + "repeat_abs_p95": 0.0, + "repeat_delta": { + "distinct_n": 1, + "max": 0.0, + "min": 0.0, + "n": 29 + } + }, + "prefill_token_fraction": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.0018186060572318308, + "action_delta": { + "distinct_n": 17, + "max": 0.8741864436917179, + "min": -0.7248107341009736, + "n": 17 + }, + "action_signs": { + "consistency": 0.6470588235294118, + "negative": 6, + "positive": 11, + "zero": 0 + }, + "effect_to_repeat_median": 0.01492870595090838, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.12181940371872435, + "repeat_abs_p95": 0.904349172685805, + "repeat_delta": { + "distinct_n": 29, + "max": 0.12181940371872435, + "min": -0.9109256423065466, + "n": 29 + } + }, + "queue_running_mean": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.4996837289, + "action_delta": { + "distinct_n": 17, + "max": 10.8362644165, + "min": -1.1173600969999997, + "n": 17 + }, + "action_signs": { + "consistency": 0.7647058823529411, + "negative": 4, + "positive": 13, + "zero": 0 + }, + "effect_to_repeat_median": 6.675982397855274, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.07484796979999953, + "repeat_abs_p95": 19.390367244779988, + "repeat_delta": { + "distinct_n": 29, + "max": 0.11568243179999982, + "min": -22.007979622, + "n": 29 + } + }, + "queue_waiting_mean": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.0, + "action_delta": { + "distinct_n": 9, + "max": 0.0, + "min": -5.5313452697, + "n": 17 + }, + "action_signs": { + "consistency": 1.0, + "negative": 8, + "positive": 0, + "zero": 9 + }, + "effect_to_repeat_median": 0.0, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.0, + "repeat_abs_p95": 5.569089138, + "repeat_delta": { + "distinct_n": 10, + "max": 0.0, + "min": -9.1442523314, + "n": 29 + } + }, + "scheduler_steps_per_s": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 6.0, + "action_delta": { + "distinct_n": 17, + "max": 55.0, + "min": -89.4, + "n": 17 + }, + "action_signs": { + "consistency": 0.6470588235294118, + "negative": 11, + "positive": 6, + "zero": 0 + }, + "effect_to_repeat_median": 2.8571428571428648, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 2.0999999999999943, + "repeat_abs_p95": 136.72000000000003, + "repeat_delta": { + "distinct_n": 24, + "max": 143.3, + "min": -28.89999999999999, + "n": 29 + } + } + }, + "horizon_s": 10.0, + "qualifying_features": [], + "repeats": [ + { + "delta_state": { + "batch_size.mean": -0.032046759505486744, + "batch_tokens.mean": -0.6567641003932749, + "decode_batch_size.mean": -0.031829677307312565, + "graph_full_share": 0.00020803710658368058, + "graph_none_share": -0.00019899201499314415, + "graph_padding_fraction": -0.0002750356645350475, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": -4.977600796418624e-05, + "kv_usage_mean": -0.0014423226092831615, + "preemptions": 0.0, + "prefill_token_fraction": 6.688650356756476e-05, + "queue_running_mean": -0.1142690622, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.5 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.25, + "request_hash": "26629995f38f2c013d5aa5e4b9d7344311ab1f951c9d83e68212c67ca8076fda", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp1_mns16/anchor-0.25/result.json" + }, + "target": { + "cell": "tp1_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp1_mns16/confirm-1-anchor-0.25/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.026614995471553993, + "batch_tokens.mean": -0.6496552246722729, + "decode_batch_size.mean": -0.02639849605068978, + "graph_full_share": 0.00020747861166137138, + "graph_none_share": -0.00018041618405337592, + "graph_padding_fraction": -9.631257646229227e-05, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -0.00015576460470852899, + "preemptions": 0.0, + "prefill_token_fraction": 1.3376556165067832e-05, + "queue_running_mean": -0.04869389649999967, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.5 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.24609375, + "request_hash": "7e48c6bfc00eeadd6011111170c31123fb117c9fa75c18ccc8d8d505fd7fcff3", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.24609375/result.json" + }, + "target": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/confirm-1-anchor-0.24609375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.010808600034953653, + "batch_tokens.mean": -0.5085699460020408, + "decode_batch_size.mean": -0.010635633606656203, + "graph_full_share": 0.0001657594937848339, + "graph_none_share": -0.00014413869024775677, + "graph_padding_fraction": -1.428081475827233e-05, + "kv_usage_end_minus_start": 9.965122072741472e-05, + "kv_usage_max": 0.0, + "kv_usage_mean": -4.734747194812261e-05, + "preemptions": 0.0, + "prefill_token_fraction": -9.363068207879355e-05, + "queue_running_mean": -0.009244884900000194, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.4000000000000057 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.25, + "request_hash": "26629995f38f2c013d5aa5e4b9d7344311ab1f951c9d83e68212c67ca8076fda", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.25/result.json" + }, + "target": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/confirm-1-anchor-0.25/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.016288869514675675, + "batch_tokens.mean": -0.5180834059866299, + "decode_batch_size.mean": -0.016114501598372577, + "graph_full_share": 0.00016710258645746823, + "graph_none_share": -0.00013804126707352496, + "graph_padding_fraction": -0.00023422744992916602, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": -4.995504046367838e-05, + "kv_usage_mean": -0.0007559762079877713, + "preemptions": 0.0, + "prefill_token_fraction": -4.013301897864974e-05, + "queue_running_mean": -0.07447232549999949, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.4000000000000057 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.24609375, + "request_hash": "7e48c6bfc00eeadd6011111170c31123fb117c9fa75c18ccc8d8d505fd7fcff3", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp1_mns64/anchor-0.24609375/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp1_mns64/confirm-1-anchor-0.24609375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.04857934121216845, + "batch_tokens.mean": -1.5419494800797793, + "decode_batch_size.mean": -0.04806041200816624, + "graph_full_share": 0.0004973071538354468, + "graph_none_share": -0.0004108189531684403, + "graph_padding_fraction": -0.0002209229137654341, + "kv_usage_end_minus_start": 9.991008092724574e-05, + "kv_usage_max": -4.995504046367838e-05, + "kv_usage_mean": -0.0009120779275651192, + "preemptions": 0.0, + "prefill_token_fraction": -0.00012037560603939124, + "queue_running_mean": -0.07484796979999953, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 1.1999999999999886 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.25, + "request_hash": "26629995f38f2c013d5aa5e4b9d7344311ab1f951c9d83e68212c67ca8076fda", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp1_mns64/anchor-0.25/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp1_mns64/confirm-1-anchor-0.25/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.648283558063266, + "batch_tokens.mean": 49.961881401529, + "decode_batch_size.mean": 0.6427639871873927, + "graph_full_share": -0.006350826071218729, + "graph_none_share": 0.014663378024668453, + "graph_padding_fraction": -0.016377336933075942, + "kv_usage_end_minus_start": 4.9753719090550597e-05, + "kv_usage_max": 0.004527588437235774, + "kv_usage_mean": 0.00522340215966962, + "preemptions": 0.0, + "prefill_token_fraction": 0.12181940371872435, + "queue_running_mean": 0.11568243179999982, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -28.89999999999999 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.2265625, + "request_hash": "a05848006335fc9f595432bab793a13d427244886e4f04e51ba74d495453ef90", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.9920634920634921, + "mns": 8, + "trial_id": "tp1_mns8/anchor-0.2265625/result.json" + }, + "target": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.9920634920634921, + "mns": 8, + "trial_id": "tp1_mns8/confirm-1-anchor-0.2265625/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.003282275711160132, + "batch_tokens.mean": 0.03829321663019414, + "decode_batch_size.mean": 0.003282275711159688, + "graph_full_share": 0.0, + "graph_none_share": 0.0, + "graph_padding_fraction": 6.231700658618396e-05, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -4.5836795611722825e-05, + "preemptions": 0.0, + "prefill_token_fraction": -2.6373628770337554e-05, + "queue_running_mean": -0.0024092132999999905, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.0 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.23046875, + "request_hash": "0f4c973153935c8abcd421eb631900670e31af0dc8a33bdf7e4d3d85e7ed7711", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.9923076923076923, + "mns": 8, + "trial_id": "tp1_mns8/anchor-0.23046875/result.json" + }, + "target": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.9923076923076923, + "mns": 8, + "trial_id": "tp1_mns8/confirm-1-anchor-0.23046875/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.016918595496772326, + "batch_tokens.mean": -0.47955440088175294, + "decode_batch_size.mean": -0.0167453944260747, + "graph_full_share": 0.00017320107069751511, + "graph_none_share": -0.000173201070697529, + "graph_padding_fraction": 3.159090949033175e-05, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -1.8095624633056306e-05, + "preemptions": 0.0, + "prefill_token_fraction": -4.685685224570246e-05, + "queue_running_mean": -0.005980747899999805, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.5999999999999943 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.234375, + "request_hash": "14d2a74fffe25e7d9b3e7490c392eae0dc31bb1f3fe6566c9c0a567543bdd6ac", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.9924242424242424, + "mns": 8, + "trial_id": "tp1_mns8/anchor-0.234375/result.json" + }, + "target": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.9924242424242424, + "mns": 8, + "trial_id": "tp1_mns8/confirm-1-anchor-0.234375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.05339622914945741, + "batch_tokens.mean": -1.3045555990319286, + "decode_batch_size.mean": -0.05296146544353153, + "graph_full_share": 0.0004166485515122442, + "graph_none_share": -0.00041664855151225116, + "graph_padding_fraction": -5.497908988029605e-05, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -0.0003624675799889579, + "preemptions": 0.0, + "prefill_token_fraction": 2.675497368564983e-05, + "queue_running_mean": -0.03772782840000044, + "queue_waiting_mean": -0.0204415657, + "scheduler_steps_per_s": 1.0 + }, + "descriptive_full_outcome": { + "delta_pass_rate": -0.006993006993006978, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.25, + "request_hash": "26629995f38f2c013d5aa5e4b9d7344311ab1f951c9d83e68212c67ca8076fda", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.958041958041958, + "mns": 8, + "trial_id": "tp1_mns8/anchor-0.25/result.json" + }, + "target": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.951048951048951, + "mns": 8, + "trial_id": "tp1_mns8/confirm-1-anchor-0.25/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -1.5223872504055418, + "batch_tokens.mean": -69.8055007051478, + "decode_batch_size.mean": -1.5056685448852059, + "graph_full_share": 0.017265452376541424, + "graph_none_share": -0.025711662075298437, + "graph_padding_fraction": 0.15174913486120387, + "kv_usage_end_minus_start": -0.009853977330746444, + "kv_usage_max": -0.01946543449402638, + "kv_usage_mean": -0.008432216411693306, + "preemptions": 0.0, + "prefill_token_fraction": -0.8614186464282653, + "queue_running_mean": -3.6705211939, + "queue_waiting_mean": -0.0093291794, + "scheduler_steps_per_s": 74.0 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.49609375, + "request_hash": "a78992ce59bb3b857a7ef8844e0a690ea9dd529a659cf5edd599b63fef8b6a80", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp2_mns16/anchor-0.49609375/result.json" + }, + "target": { + "cell": "tp2_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp2_mns16/confirm-1-anchor-0.49609375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.007251432291120796, + "batch_tokens.mean": -0.00762511250828668, + "decode_batch_size.mean": -0.007211010152244679, + "graph_full_share": 3.9523869123314626e-05, + "graph_none_share": 0.0, + "graph_padding_fraction": -0.0023343164243360137, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -1.4972595796737716e-05, + "preemptions": 0.0, + "prefill_token_fraction": 5.034578599764916e-05, + "queue_running_mean": -0.006232385800000184, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.30000000000001137 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.5, + "request_hash": "3160017dbd8249f711eb115f1e72ddbb37eab3a3333a48762cc3104e94bd2f15", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp2_mns16/anchor-0.5/result.json" + }, + "target": { + "cell": "tp2_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp2_mns16/confirm-1-anchor-0.5/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.001311475409836227, + "batch_tokens.mean": -0.001311475409836227, + "decode_batch_size.mean": -0.001311475409836227, + "graph_full_share": 0.0, + "graph_none_share": 0.0, + "graph_padding_fraction": -0.00024782551484880955, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -2.119802975337863e-05, + "preemptions": 0.0, + "prefill_token_fraction": 1.920108243574914e-05, + "queue_running_mean": -0.0037054131000004986, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.0 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.75, + "request_hash": "4f4c792e90f5c1bf33978fea26debcadfce5f8b872a31be86a88a1bf6b09a21c", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp2_mns32/anchor-0.75/result.json" + }, + "target": { + "cell": "tp2_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp2_mns32/confirm-1-anchor-0.75/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -5.253278252178259, + "batch_tokens.mean": -203.60648072702782, + "decode_batch_size.mean": -5.198083023705538, + "graph_full_share": 0.03511966842665615, + "graph_none_share": -0.043478260869565216, + "graph_padding_fraction": 0.24157911714869673, + "kv_usage_end_minus_start": -0.07211360414777734, + "kv_usage_max": -0.05893470570957904, + "kv_usage_mean": -0.034746555150565066, + "preemptions": 0.0, + "prefill_token_fraction": -0.8735909388483541, + "queue_running_mean": -12.366947709400002, + "queue_waiting_mean": -1.6375549495, + "scheduler_steps_per_s": 86.29999999999998 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.7385786802030457, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.75390625, + "request_hash": "2677a6a12ff0e104d6246dd121d0667ff4fe3d25f8d68699547906420246ebdd", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.20558375634517767, + "mns": 32, + "trial_id": "tp2_mns32/anchor-0.75390625/result.json" + }, + "target": { + "cell": "tp2_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.9441624365482234, + "mns": 32, + "trial_id": "tp2_mns32/confirm-1-anchor-0.75390625/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.0022141886965014734, + "batch_tokens.mean": -0.0023373966282491665, + "decode_batch_size.mean": -0.002200860915423153, + "graph_full_share": 1.3031608165570141e-05, + "graph_none_share": 0.0, + "graph_padding_fraction": 0.0003699622628544341, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -6.601132195046752e-06, + "preemptions": 0.0, + "prefill_token_fraction": 1.2576053067120396e-05, + "queue_running_mean": 0.0006418031000001712, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.10000000000002274 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.5, + "request_hash": "3160017dbd8249f711eb115f1e72ddbb37eab3a3333a48762cc3104e94bd2f15", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp2_mns64/anchor-0.5/result.json" + }, + "target": { + "cell": "tp2_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp2_mns64/confirm-1-anchor-0.5/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -5.415534020939959, + "batch_tokens.mean": -200.71322023330129, + "decode_batch_size.mean": -5.35913538229716, + "graph_full_share": 0.05071523213218676, + "graph_none_share": -0.05388272583201268, + "graph_padding_fraction": 0.22642208124358779, + "kv_usage_end_minus_start": -0.03352133931883006, + "kv_usage_max": -0.0609037076826664, + "kv_usage_mean": -0.02880160581001033, + "preemptions": 0.0, + "prefill_token_fraction": -0.8741576384479508, + "queue_running_mean": -10.836573950600002, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 89.4 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.6624040920716113, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.75, + "request_hash": "4f4c792e90f5c1bf33978fea26debcadfce5f8b872a31be86a88a1bf6b09a21c", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.23017902813299232, + "mns": 64, + "trial_id": "tp2_mns64/anchor-0.75/result.json" + }, + "target": { + "cell": "tp2_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.8925831202046036, + "mns": 64, + "trial_id": "tp2_mns64/confirm-1-anchor-0.75/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.04236326637336152, + "batch_tokens.mean": -0.0506303786819462, + "decode_batch_size.mean": -0.041385582574491764, + "graph_full_share": 0.0009697259074838982, + "graph_none_share": -0.000746904948671601, + "graph_padding_fraction": -0.0024530500387316967, + "kv_usage_end_minus_start": -0.005895639523754825, + "kv_usage_max": 0.0, + "kv_usage_mean": -0.0001257250352028564, + "preemptions": 0.0, + "prefill_token_fraction": -0.0014409663380382937, + "queue_running_mean": -0.0696698146000001, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 2.0999999999999943 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.4921875, + "request_hash": "cd227aee3be472a35e8c35af60a44a1411c4dc689cbd98746b3fb8a8d329b44c", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "trial_id": "tp2_mns8/anchor-0.4921875/result.json" + }, + "target": { + "cell": "tp2_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "trial_id": "tp2_mns8/confirm-1-anchor-0.4921875/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.9687249841095076, + "batch_tokens.mean": -59.73987529620144, + "decode_batch_size.mean": -0.9579959096941315, + "graph_full_share": 0.011406581190443799, + "graph_none_share": -0.019512062147118037, + "graph_padding_fraction": 0.20562784534661108, + "kv_usage_end_minus_start": 0.004504676952132969, + "kv_usage_max": -0.0037772928550463547, + "kv_usage_mean": -0.0036990145914360204, + "preemptions": 0.0, + "prefill_token_fraction": -0.8491799860125482, + "queue_running_mean": -1.3942294618000002, + "queue_waiting_mean": -1.1069323539, + "scheduler_steps_per_s": 45.69999999999999 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.6190476190476191, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.49609375, + "request_hash": "a78992ce59bb3b857a7ef8844e0a690ea9dd529a659cf5edd599b63fef8b6a80", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.27106227106227104, + "mns": 8, + "trial_id": "tp2_mns8/anchor-0.49609375/result.json" + }, + "target": { + "cell": "tp2_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.8901098901098901, + "mns": 8, + "trial_id": "tp2_mns8/confirm-1-anchor-0.49609375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.02348440960742426, + "batch_tokens.mean": -0.024462377280626946, + "decode_batch_size.mean": -0.02333965019280182, + "graph_full_share": -0.0009263480369809951, + "graph_none_share": 0.0, + "graph_padding_fraction": 0.0002862441287893591, + "kv_usage_end_minus_start": -5.101077857672109e-06, + "kv_usage_max": -1.0202155715566263e-05, + "kv_usage_mean": -2.2000789048993996e-05, + "preemptions": 0.0, + "prefill_token_fraction": 5.985572526742006e-05, + "queue_running_mean": -0.02092175199999957, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.5999999999999943 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.2469565217391304, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.033182214016, + "request_hash": "e6b624a0212807df3733c54b4a2160fba24f19ca4776b14f34918d83428bba7f", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.7530434782608696, + "mns": 16, + "trial_id": "tp4_mns16/anchor-0.033182214016/result.json" + }, + "target": { + "cell": "tp4_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp4_mns16/confirm-1-anchor-0.033182214016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -3.19743814378252, + "batch_tokens.mean": -194.8952745035574, + "decode_batch_size.mean": -3.1597031963470315, + "graph_full_share": 0.02834766910905817, + "graph_none_share": -0.04961240310077519, + "graph_padding_fraction": 0.24357765310774523, + "kv_usage_end_minus_start": -0.008034197625958361, + "kv_usage_max": -0.004550161449114243, + "kv_usage_mean": -0.008735063035535659, + "preemptions": 0.0, + "prefill_token_fraction": -0.8943849310253909, + "queue_running_mean": -6.701412029300001, + "queue_waiting_mean": -9.1442523314, + "scheduler_steps_per_s": 110.69999999999999 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.34982935153583616, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.033717411016, + "request_hash": "472a874ecc0e844b5b36a715bbc309b63e73074d39327cd734869f76721d71db", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.06313993174061433, + "mns": 16, + "trial_id": "tp4_mns16/anchor-0.033717411016/result.json" + }, + "target": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.4129692832764505, + "mns": 16, + "trial_id": "tp4_mns16/confirm-1-anchor-0.033717411016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.07980086487246574, + "batch_tokens.mean": -1.0880711819756304, + "decode_batch_size.mean": -0.07880182167344785, + "graph_full_share": -0.0018140521245323393, + "graph_none_share": -0.0016474464579901153, + "graph_padding_fraction": 0.02197042071969288, + "kv_usage_end_minus_start": 2.0404311431021505e-05, + "kv_usage_max": 0.0, + "kv_usage_mean": -8.46355932073951e-05, + "preemptions": 0.0, + "prefill_token_fraction": -0.13021608847689226, + "queue_running_mean": -0.09728112210000006, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 3.8000000000000114 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.034252608017, + "request_hash": "21c1f3b7d972b19c952a894863a70d1e85bd0e24a7e7b6b0fcc088360d0e01bd", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp4_mns16/anchor-0.034252608017/result.json" + }, + "target": { + "cell": "tp4_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp4_mns16/confirm-1-anchor-0.034252608017/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.006431552476177771, + "batch_tokens.mean": -0.006758232721721491, + "decode_batch_size.mean": -0.006383197052567624, + "graph_full_share": 0.000573798951080895, + "graph_none_share": 0.0, + "graph_padding_fraction": 0.0006374012583605093, + "kv_usage_end_minus_start": -5.101077857672109e-06, + "kv_usage_max": -5.101077857783132e-06, + "kv_usage_mean": -1.0214925773703067e-05, + "preemptions": 0.0, + "prefill_token_fraction": 5.436516758668131e-06, + "queue_running_mean": -0.009119564499999733, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.19999999999998863 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.2469565217391304, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.033182214016, + "request_hash": "e6b624a0212807df3733c54b4a2160fba24f19ca4776b14f34918d83428bba7f", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.7530434782608696, + "mns": 16, + "trial_id": "tp4_mns16/anchor-0.033182214016/result.json" + }, + "target": { + "cell": "tp4_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp4_mns16/confirm-2-anchor-0.033182214016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -5.684231334296602, + "batch_tokens.mean": -242.26991192050903, + "decode_batch_size.mean": -5.614987163710968, + "graph_full_share": 0.03905791041999285, + "graph_none_share": -0.04780114722753346, + "graph_padding_fraction": 0.23825248667744758, + "kv_usage_end_minus_start": -0.028101561821904375, + "kv_usage_max": -0.02156120922490945, + "kv_usage_mean": -0.01815563294515909, + "preemptions": 0.0, + "prefill_token_fraction": -0.89493540395689, + "queue_running_mean": -16.051436879700002, + "queue_waiting_mean": -5.569089138, + "scheduler_steps_per_s": 136.8 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.9692832764505119, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.033717411016, + "request_hash": "472a874ecc0e844b5b36a715bbc309b63e73074d39327cd734869f76721d71db", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.030716723549488054, + "mns": 32, + "trial_id": "tp4_mns32/anchor-0.033717411016/result.json" + }, + "target": { + "cell": "tp4_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp4_mns32/confirm-1-anchor-0.033717411016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.07573170158789821, + "batch_tokens.mean": -1.0733751057032785, + "decode_batch_size.mean": -0.07518292539697491, + "graph_full_share": 0.0010444071220520046, + "graph_none_share": -0.0010899182561307902, + "graph_padding_fraction": 0.027146526691836648, + "kv_usage_end_minus_start": -5.105661668114436e-06, + "kv_usage_max": -5.1056616682254585e-06, + "kv_usage_mean": -6.434458670689751e-05, + "preemptions": 0.0, + "prefill_token_fraction": -0.1289638873088742, + "queue_running_mean": -0.0711253370999998, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 2.0999999999999943 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.034252608017, + "request_hash": "21c1f3b7d972b19c952a894863a70d1e85bd0e24a7e7b6b0fcc088360d0e01bd", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp4_mns32/anchor-0.034252608017/result.json" + }, + "target": { + "cell": "tp4_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp4_mns32/confirm-1-anchor-0.034252608017/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -5.676772134537581, + "batch_tokens.mean": -242.26212742181514, + "decode_batch_size.mean": -5.607576114913048, + "graph_full_share": 0.039014238618063524, + "graph_none_share": -0.04780114722753346, + "graph_padding_fraction": 0.23544552622699638, + "kv_usage_end_minus_start": -0.02810666748357249, + "kv_usage_max": -0.021556103563241225, + "kv_usage_mean": -0.01814814993745567, + "preemptions": 0.0, + "prefill_token_fraction": -0.8949517370921197, + "queue_running_mean": -16.0413130873, + "queue_waiting_mean": -5.569089138, + "scheduler_steps_per_s": 136.60000000000002 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.9692832764505119, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.033717411016, + "request_hash": "472a874ecc0e844b5b36a715bbc309b63e73074d39327cd734869f76721d71db", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.030716723549488054, + "mns": 32, + "trial_id": "tp4_mns32/anchor-0.033717411016/result.json" + }, + "target": { + "cell": "tp4_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp4_mns32/confirm-2-anchor-0.033717411016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -4.9280804627990085, + "batch_tokens.mean": -364.01800389606234, + "decode_batch_size.mean": -4.782726800328038, + "graph_full_share": 0.05329256669728677, + "graph_none_share": -0.06263498920086392, + "graph_padding_fraction": 0.2448027632667215, + "kv_usage_end_minus_start": -0.05014161119802052, + "kv_usage_max": -0.039318834800568414, + "kv_usage_mean": -0.022291899962727596, + "preemptions": 0.0, + "prefill_token_fraction": -0.9106141297482617, + "queue_running_mean": -21.6163208215, + "queue_waiting_mean": -0.1743790356, + "scheduler_steps_per_s": 129.10000000000002 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.8430034129692833, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.033717411016, + "request_hash": "472a874ecc0e844b5b36a715bbc309b63e73074d39327cd734869f76721d71db", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.11433447098976109, + "mns": 64, + "trial_id": "tp4_mns64/anchor-0.033717411016/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.9573378839590444, + "mns": 64, + "trial_id": "tp4_mns64/confirm-1-anchor-0.033717411016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.0986378480703829, + "batch_tokens.mean": -1.1003885983709436, + "decode_batch_size.mean": -0.09787917001031765, + "graph_full_share": 0.00015255866453844913, + "graph_none_share": -0.001092896174863388, + "graph_padding_fraction": 0.026001990897698585, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -8.10913166477481e-05, + "preemptions": 0.0, + "prefill_token_fraction": -0.1290526738911407, + "queue_running_mean": -0.09155397830000034, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 2.9000000000000057 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.034252608017, + "request_hash": "21c1f3b7d972b19c952a894863a70d1e85bd0e24a7e7b6b0fcc088360d0e01bd", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp4_mns64/anchor-0.034252608017/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp4_mns64/confirm-1-anchor-0.034252608017/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -5.343712123283302, + "batch_tokens.mean": -364.45844383082266, + "decode_batch_size.mean": -5.194686323828272, + "graph_full_share": 0.055525557955363625, + "graph_none_share": -0.06263498920086392, + "graph_padding_fraction": 0.2382752171480348, + "kv_usage_end_minus_start": -0.05152704927251717, + "kv_usage_max": -0.0393392840710407, + "kv_usage_mean": -0.022618048328561978, + "preemptions": 0.0, + "prefill_token_fraction": -0.9109256423065466, + "queue_running_mean": -22.007979622, + "queue_waiting_mean": -0.1743790356, + "scheduler_steps_per_s": 143.3 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.8856655290102389, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.033717411016, + "request_hash": "472a874ecc0e844b5b36a715bbc309b63e73074d39327cd734869f76721d71db", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.11433447098976109, + "mns": 64, + "trial_id": "tp4_mns64/anchor-0.033717411016/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp4_mns64/confirm-2-anchor-0.033717411016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.5747954473735191, + "batch_tokens.mean": -30.476142999621462, + "decode_batch_size.mean": -0.5686361081847746, + "graph_full_share": 0.006538565006766528, + "graph_none_share": -0.017039834454924494, + "graph_padding_fraction": 0.1583386005746088, + "kv_usage_end_minus_start": -0.002356121069944095, + "kv_usage_max": 0.0, + "kv_usage_mean": -0.0006074327722416259, + "preemptions": 0.0, + "prefill_token_fraction": -0.8386345381065662, + "queue_running_mean": -0.9726716715000001, + "queue_waiting_mean": -0.428824454, + "scheduler_steps_per_s": 40.900000000000006 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.016591107009, + "request_hash": "2407501cda53bf9c761c448dc50ab4780b4a55958cc00ba1b19cd09de1cf73e1", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "trial_id": "tp4_mns8/anchor-0.016591107009/result.json" + }, + "target": { + "cell": "tp4_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "trial_id": "tp4_mns8/confirm-1-anchor-0.016591107009/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.03238588118373942, + "batch_tokens.mean": -2.9133132020797436, + "decode_batch_size.mean": -0.0321242294926507, + "graph_full_share": 0.00025027553060685825, + "graph_none_share": -0.0009881332994778795, + "graph_padding_fraction": 0.06450969515475685, + "kv_usage_end_minus_start": 5.099829155752467e-06, + "kv_usage_max": 0.0, + "kv_usage_mean": -4.0493927196364344e-05, + "preemptions": 0.0, + "prefill_token_fraction": -0.4656521349077925, + "queue_running_mean": -0.06308746549999977, + "queue_waiting_mean": -0.0015971439000000004, + "scheduler_steps_per_s": 2.5 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.017126304009, + "request_hash": "93cd99ebf2a760cc440dce0cb7e51273686dcfbfb07650d27e9e16d2ff1d2eed", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "trial_id": "tp4_mns8/anchor-0.017126304009/result.json" + }, + "target": { + "cell": "tp4_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "trial_id": "tp4_mns8/confirm-1-anchor-0.017126304009/result.json" + } + } + ], + "sanity": { + "action_pairs": 17, + "distinct_action_vectors": 17, + "invariants": { + "all_pair_hashes_match": true, + "all_values_finite": true, + "expected_action_pair_count": true, + "nonnegative_counters": true, + "ratios_bounded": true, + "state_vectors_not_all_identical": true, + "sufficient_repeat_pair_count": true + }, + "red_flags": [], + "repeat_pairs": 29, + "trials": 66 + } + }, + "5": { + "actions": [ + { + "delta_state": { + "batch_size.mean": 3.5280207937111703, + "batch_tokens.mean": 189.10013313046787, + "decode_batch_size.mean": 3.495993406872068, + "graph_full_share": -0.027843286420692226, + "graph_none_share": 0.04184100418410042, + "graph_padding_fraction": -0.10888597553063217, + "kv_usage_end_minus_start": 0.04832989960722345, + "kv_usage_max": 0.05576515049492037, + "kv_usage_mean": 0.04101485276318234, + "preemptions": 0.0, + "prefill_token_fraction": 0.8861120723274618, + "queue_running_mean": 3.4413866424000004, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -84.2 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.24609375, + "request_hash": "7e48c6bfc00eeadd6011111170c31123fb117c9fa75c18ccc8d8d505fd7fcff3", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp1_mns16/anchor-0.24609375/result.json" + }, + "target": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.24609375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.05698177434224494, + "batch_tokens.mean": 2.4183568541238287, + "decode_batch_size.mean": 0.056343521736047286, + "graph_full_share": -0.0005850648890149968, + "graph_none_share": 0.000531877171831785, + "graph_padding_fraction": 0.00021749194258890905, + "kv_usage_end_minus_start": 7.313298449929118e-05, + "kv_usage_max": 0.00030157213266412963, + "kv_usage_mean": 0.0016340770443056124, + "preemptions": 0.0, + "prefill_token_fraction": 8.473923694440888e-05, + "queue_running_mean": 0.1474536237999997, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -0.5999999999999943 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.24609375, + "request_hash": "7e48c6bfc00eeadd6011111170c31123fb117c9fa75c18ccc8d8d505fd7fcff3", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.24609375/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp1_mns64/anchor-0.24609375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.1278554259770317, + "batch_tokens.mean": 3.2897534051455466, + "decode_batch_size.mean": 0.127000801210718, + "graph_full_share": -0.0007834060357874151, + "graph_none_share": -0.0034719131131487613, + "graph_padding_fraction": 0.0008694893399684026, + "kv_usage_end_minus_start": 2.1174429976178466e-05, + "kv_usage_max": 0.03040170172083234, + "kv_usage_mean": 0.005773282024914478, + "preemptions": 0.0, + "prefill_token_fraction": -0.0001483422608830054, + "queue_running_mean": 0.5028872580000003, + "queue_waiting_mean": -0.0510258954, + "scheduler_steps_per_s": -0.7999999999999972 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.04195804195804198, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.25, + "request_hash": "26629995f38f2c013d5aa5e4b9d7344311ab1f951c9d83e68212c67ca8076fda", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.958041958041958, + "mns": 8, + "trial_id": "tp1_mns8/anchor-0.25/result.json" + }, + "target": { + "cell": "tp1_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp1_mns16/anchor-0.25/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.06163060969068468, + "batch_tokens.mean": -2.443018058287123, + "decode_batch_size.mean": -0.06098694797067772, + "graph_full_share": 0.0005900232433398989, + "graph_none_share": -0.0005363847666726221, + "graph_padding_fraction": -0.00017399768727638983, + "kv_usage_end_minus_start": 4.7122279587474836e-05, + "kv_usage_max": 0.00011557359098801623, + "kv_usage_mean": -0.0004086366142161957, + "preemptions": 0.0, + "prefill_token_fraction": -6.356136875318441e-05, + "queue_running_mean": -0.0843407528000002, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.6000000000000014 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.25, + "request_hash": "26629995f38f2c013d5aa5e4b9d7344311ab1f951c9d83e68212c67ca8076fda", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp1_mns16/anchor-0.25/result.json" + }, + "target": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.25/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.024589582668510523, + "batch_tokens.mean": 0.8116866999964429, + "decode_batch_size.mean": 0.02437683934333279, + "graph_full_share": -0.00019501471474669962, + "graph_none_share": 0.00017728610431513858, + "graph_padding_fraction": 8.69181567518763e-05, + "kv_usage_end_minus_start": 0.00012295859486299854, + "kv_usage_max": 0.00030157213266412963, + "kv_usage_mean": 0.00032121484848791904, + "preemptions": 0.0, + "prefill_token_fraction": 0.0, + "queue_running_mean": 0.013309304399999888, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -0.20000000000000284 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.25, + "request_hash": "26629995f38f2c013d5aa5e4b9d7344311ab1f951c9d83e68212c67ca8076fda", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.25/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp1_mns64/anchor-0.25/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 4.473159643294283, + "batch_tokens.mean": 189.17581745060323, + "decode_batch_size.mean": 4.408288162266131, + "graph_full_share": -0.046424200034971164, + "graph_none_share": 0.03890540304248993, + "graph_padding_fraction": 0.005662578660898298, + "kv_usage_end_minus_start": 0.08863131728902607, + "kv_usage_max": 0.08590208433411406, + "kv_usage_mean": 0.0354576817886873, + "preemptions": 0.0, + "prefill_token_fraction": 0.0007191134183018866, + "queue_running_mean": 3.8361017661999997, + "queue_waiting_mean": -1.0501423682, + "scheduler_steps_per_s": -7.799999999999997 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.06521739130434782, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.5, + "request_hash": "3160017dbd8249f711eb115f1e72ddbb37eab3a3333a48762cc3104e94bd2f15", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.09057971014492754, + "mns": 8, + "trial_id": "tp1_mns8/anchor-0.5/result.json" + }, + "target": { + "cell": "tp1_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.15579710144927536, + "mns": 16, + "trial_id": "tp1_mns16/anchor-0.5/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -1.4603817235396175, + "batch_tokens.mean": 220.88027761711976, + "decode_batch_size.mean": -1.5222672064777338, + "graph_full_share": -0.06998264893001727, + "graph_none_share": 0.055523423944476596, + "graph_padding_fraction": 0.0002698844942520852, + "kv_usage_end_minus_start": 0.03428564980259485, + "kv_usage_max": 0.03430172098005413, + "kv_usage_mean": 0.004527112114386889, + "preemptions": 0.0, + "prefill_token_fraction": 0.009687903063064107, + "queue_running_mean": 0.49739668660000014, + "queue_waiting_mean": -0.4414553072, + "scheduler_steps_per_s": -8.400000000000002 + }, + "descriptive_full_outcome": { + "delta_pass_rate": -0.06521739130434782, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.5, + "request_hash": "3160017dbd8249f711eb115f1e72ddbb37eab3a3333a48762cc3104e94bd2f15", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.15579710144927536, + "mns": 16, + "trial_id": "tp1_mns16/anchor-0.5/result.json" + }, + "target": { + "cell": "tp1_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.09057971014492754, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.5/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.0, + "batch_tokens.mean": 0.0, + "decode_batch_size.mean": 0.0, + "graph_full_share": 0.0, + "graph_none_share": 0.0, + "graph_padding_fraction": 0.0, + "kv_usage_end_minus_start": 0.0004933875406503141, + "kv_usage_max": 0.0005353228930036202, + "kv_usage_mean": 0.0001535070867022259, + "preemptions": 0.0, + "prefill_token_fraction": 0.0, + "queue_running_mean": -0.00963330859999978, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.0 + }, + "descriptive_full_outcome": { + "delta_pass_rate": -0.02898550724637681, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.5, + "request_hash": "3160017dbd8249f711eb115f1e72ddbb37eab3a3333a48762cc3104e94bd2f15", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.09057971014492754, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.5/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.06159420289855073, + "mns": 64, + "trial_id": "tp1_mns64/anchor-0.5/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.06154364887467256, + "batch_tokens.mean": 0.0673666044072565, + "decode_batch_size.mean": 0.06098464514354429, + "graph_full_share": -0.0005590037311280494, + "graph_none_share": 0.0, + "graph_padding_fraction": 0.005655833585839015, + "kv_usage_end_minus_start": -2.459171897339907e-06, + "kv_usage_max": 0.003445359565031225, + "kv_usage_mean": 0.0015597623110467189, + "preemptions": 0.0, + "prefill_token_fraction": 0.00030636946592198233, + "queue_running_mean": 0.12847152480000013, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -4.200000000000017 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.2421875, + "request_hash": "adb62bea7f7a12c1e33fa1572ec1d0e274100013ad90e14c6ef5c549b0e0d017", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "mns_increase", + "source": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.2421875/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp1_mns64/anchor-0.2421875/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.23325211580663785, + "batch_tokens.mean": -0.2519983270912536, + "decode_batch_size.mean": -0.23134894714830168, + "graph_full_share": 0.001903168658336507, + "graph_none_share": -0.006795016987542469, + "graph_padding_fraction": -0.004536339467287626, + "kv_usage_end_minus_start": 5.075521287700724e-07, + "kv_usage_max": -2.1953909969063545e-05, + "kv_usage_mean": -0.0005894447334146543, + "preemptions": 0.0, + "prefill_token_fraction": -6.083338940097993e-05, + "queue_running_mean": -0.27085744499999986, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 16.200000000000017 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.4921875, + "request_hash": "cd227aee3be472a35e8c35af60a44a1411c4dc689cbd98746b3fb8a8d329b44c", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "mns_increase", + "source": { + "cell": "tp2_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "trial_id": "tp2_mns8/anchor-0.4921875/result.json" + }, + "target": { + "cell": "tp2_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp2_mns16/anchor-0.4921875/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.6005778377124296, + "batch_tokens.mean": -4.162510512731277, + "decode_batch_size.mean": -0.5951764688823156, + "graph_full_share": 0.005401368830114217, + "graph_none_share": -0.01149694043268952, + "graph_padding_fraction": -0.004587093073780198, + "kv_usage_end_minus_start": 1.4354961987761428e-05, + "kv_usage_max": -0.0029570125473361575, + "kv_usage_mean": -0.0013514937493694472, + "preemptions": 0.0, + "prefill_token_fraction": -0.0010977628546262608, + "queue_running_mean": -0.5356197792000001, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 29.799999999999983 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.728937728937729, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.49609375, + "request_hash": "a78992ce59bb3b857a7ef8844e0a690ea9dd529a659cf5edd599b63fef8b6a80", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "mns_increase", + "source": { + "cell": "tp2_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.27106227106227104, + "mns": 8, + "trial_id": "tp2_mns8/anchor-0.49609375/result.json" + }, + "target": { + "cell": "tp2_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp2_mns16/anchor-0.49609375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.35712385038833183, + "batch_tokens.mean": 111.90975236574697, + "decode_batch_size.mean": 0.32775366295797426, + "graph_full_share": -0.025012888955412538, + "graph_none_share": 0.026143790849673203, + "graph_padding_fraction": -0.2241759801940655, + "kv_usage_end_minus_start": 0.03485111013888609, + "kv_usage_max": 0.01867744710795105, + "kv_usage_mean": 0.006535245430020315, + "preemptions": 0.0, + "prefill_token_fraction": 0.8766852234122235, + "queue_running_mean": 2.085466555, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -65.39999999999999 + }, + "descriptive_full_outcome": { + "delta_pass_rate": -0.7698209718670077, + "feasibility_transition": "true->false" + }, + "group": { + "anchor": 0.75, + "request_hash": "4f4c792e90f5c1bf33978fea26debcadfce5f8b872a31be86a88a1bf6b09a21c", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "mns_increase", + "source": { + "cell": "tp2_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp2_mns32/anchor-0.75/result.json" + }, + "target": { + "cell": "tp2_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.23017902813299232, + "mns": 64, + "trial_id": "tp2_mns64/anchor-0.75/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.8613841701826859, + "batch_tokens.mean": 99.28363780953853, + "decode_batch_size.mean": -0.9000309262409161, + "graph_full_share": -0.013132607303010913, + "graph_none_share": 0.007356027303452698, + "graph_padding_fraction": -0.002483113089604908, + "kv_usage_end_minus_start": 0.013972653351394082, + "kv_usage_max": 0.013923980316157603, + "kv_usage_mean": 0.002289615839773029, + "preemptions": 0.0, + "prefill_token_fraction": 0.027119159852510122, + "queue_running_mean": 2.255338312400001, + "queue_waiting_mean": -1.3976082232, + "scheduler_steps_per_s": -8.0 + }, + "descriptive_full_outcome": { + "delta_pass_rate": -0.032423208191126277, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.033717411016, + "request_hash": "472a874ecc0e844b5b36a715bbc309b63e73074d39327cd734869f76721d71db", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.06313993174061433, + "mns": 16, + "trial_id": "tp4_mns16/anchor-0.033717411016/result.json" + }, + "target": { + "cell": "tp4_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.030716723549488054, + "mns": 32, + "trial_id": "tp4_mns32/anchor-0.033717411016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.00950293278090264, + "batch_tokens.mean": -1.5782094981150578, + "decode_batch_size.mean": -0.008726077059269421, + "graph_full_share": 0.0005239259517987316, + "graph_none_share": -0.00023486335770291772, + "graph_padding_fraction": 8.79877867886172e-05, + "kv_usage_end_minus_start": 3.819849616093496e-05, + "kv_usage_max": 4.159303058193231e-05, + "kv_usage_mean": 6.884522888032929e-05, + "preemptions": 0.0, + "prefill_token_fraction": -0.00013165055575314888, + "queue_running_mean": 0.02412652539999982, + "queue_waiting_mean": -9.661300000000927e-05, + "scheduler_steps_per_s": 0.5999999999999943 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.08361774744027303, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.033717411016, + "request_hash": "472a874ecc0e844b5b36a715bbc309b63e73074d39327cd734869f76721d71db", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "mns_increase", + "source": { + "cell": "tp4_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.030716723549488054, + "mns": 32, + "trial_id": "tp4_mns32/anchor-0.033717411016/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.11433447098976109, + "mns": 64, + "trial_id": "tp4_mns64/anchor-0.033717411016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.7391144064912778, + "batch_tokens.mean": -97.02946180778741, + "decode_batch_size.mean": -0.7271776858566685, + "graph_full_share": 0.015299949334160123, + "graph_none_share": -0.04103743978705223, + "graph_padding_fraction": 0.21027653696749515, + "kv_usage_end_minus_start": -0.006308261401860582, + "kv_usage_max": 0.004195788190260341, + "kv_usage_mean": -0.0005148594359863203, + "preemptions": 0.0, + "prefill_token_fraction": -0.7248910361224853, + "queue_running_mean": -0.7297395955999999, + "queue_waiting_mean": -3.4976107514, + "scheduler_steps_per_s": 59.80000000000001 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.8216666666666667, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.034252608017, + "request_hash": "21c1f3b7d972b19c952a894863a70d1e85bd0e24a7e7b6b0fcc088360d0e01bd", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "mns_increase", + "source": { + "cell": "tp4_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.17833333333333334, + "mns": 8, + "trial_id": "tp4_mns8/anchor-0.034252608017/result.json" + }, + "target": { + "cell": "tp4_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp4_mns16/anchor-0.034252608017/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.0033632286995510796, + "batch_tokens.mean": -0.0033632286995510796, + "decode_batch_size.mean": -0.003363228699551968, + "graph_full_share": 0.0, + "graph_none_share": 0.0, + "graph_padding_fraction": -0.0030699089127894374, + "kv_usage_end_minus_start": 8.342535059435718e-07, + "kv_usage_max": 1.368725807104898e-05, + "kv_usage_mean": -6.535810642852545e-06, + "preemptions": 0.0, + "prefill_token_fraction": 9.850983893985865e-05, + "queue_running_mean": -0.009463884000000533, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.0 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.034252608017, + "request_hash": "21c1f3b7d972b19c952a894863a70d1e85bd0e24a7e7b6b0fcc088360d0e01bd", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "mns_increase", + "source": { + "cell": "tp4_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp4_mns16/anchor-0.034252608017/result.json" + }, + "target": { + "cell": "tp4_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp4_mns32/anchor-0.034252608017/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.01835841147659245, + "batch_tokens.mean": 0.02343919454014376, + "decode_batch_size.mean": 0.01819951878212578, + "graph_full_share": -0.0012724026088667406, + "graph_none_share": 3.7831593920716316e-06, + "graph_padding_fraction": 0.0006955531292226758, + "kv_usage_end_minus_start": 1.2113828717907893e-06, + "kv_usage_max": 1.9874666237429395e-05, + "kv_usage_mean": 2.5481750126793087e-05, + "preemptions": 0.0, + "prefill_token_fraction": 3.285684502737918e-05, + "queue_running_mean": 0.018367366400000584, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -0.5999999999999943 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.034252608017, + "request_hash": "21c1f3b7d972b19c952a894863a70d1e85bd0e24a7e7b6b0fcc088360d0e01bd", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "mns_increase", + "source": { + "cell": "tp4_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp4_mns32/anchor-0.034252608017/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp4_mns64/anchor-0.034252608017/result.json" + } + } + ], + "descriptive_full_outcome": { + "delta_pass_rate": { + "distinct_n": 10, + "max": 0.8216666666666667, + "min": -0.7698209718670077, + "n": 17 + }, + "feasibility_transitions": { + "false->false": 5, + "false->true": 2, + "true->false": 1, + "true->true": 9 + }, + "limitation": "Full outcomes may use different elapsed durations when a trial early-stopped; they are descriptive and are not a gate input.", + "negative": 4, + "positive": 5, + "zero": 8 + }, + "feature_statistics": { + "batch_size.mean": { + "action_above_repeat_p95_fraction": 0.35294117647058826, + "action_abs_median": 0.1278554259770317, + "action_delta": { + "distinct_n": 17, + "max": 4.473159643294283, + "min": -1.4603817235396175, + "n": 17 + }, + "action_signs": { + "consistency": 0.5, + "negative": 8, + "positive": 8, + "zero": 1 + }, + "effect_to_repeat_median": 1.9564724489442589, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.06534997517906493, + "repeat_abs_p95": 0.4689572472409891, + "repeat_delta": { + "distinct_n": 29, + "max": 0.9280844155844155, + "min": -0.373100622158411, + "n": 29 + } + }, + "batch_tokens.mean": { + "action_above_repeat_p95_fraction": 0.058823529411764705, + "action_abs_median": 2.443018058287123, + "action_delta": { + "distinct_n": 17, + "max": 220.88027761711976, + "min": -97.02946180778741, + "n": 17 + }, + "action_signs": { + "consistency": 0.625, + "negative": 6, + "positive": 10, + "zero": 1 + }, + "effect_to_repeat_median": 1.016963189345596, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 2.402267932489451, + "repeat_abs_p95": 212.7553678215874, + "repeat_delta": { + "distinct_n": 29, + "max": 100.79992784992785, + "min": -213.38441949985196, + "n": 29 + } + }, + "decode_batch_size.mean": { + "action_above_repeat_p95_fraction": 0.35294117647058826, + "action_abs_median": 0.127000801210718, + "action_delta": { + "distinct_n": 17, + "max": 4.408288162266131, + "min": -1.5222672064777338, + "n": 17 + }, + "action_signs": { + "consistency": 0.5, + "negative": 8, + "positive": 8, + "zero": 1 + }, + "effect_to_repeat_median": 1.9625625182162536, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.06471172257286728, + "repeat_abs_p95": 0.5074569452309783, + "repeat_delta": { + "distinct_n": 29, + "max": 0.9185245310245311, + "min": -0.36846434553720986, + "n": 29 + } + }, + "graph_full_share": { + "action_above_repeat_p95_fraction": 0.11764705882352941, + "action_abs_median": 0.0012724026088667406, + "action_delta": { + "distinct_n": 16, + "max": 0.015299949334160123, + "min": -0.06998264893001727, + "n": 17 + }, + "action_signs": { + "consistency": 0.6666666666666666, + "negative": 10, + "positive": 5, + "zero": 2 + }, + "effect_to_repeat_median": 1.8902399214885985, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.0006731434430105043, + "repeat_abs_p95": 0.029715971438244844, + "repeat_delta": { + "distinct_n": 28, + "max": 0.029898516783762652, + "min": -0.009559884559884546, + "n": 29 + } + }, + "graph_none_share": { + "action_above_repeat_p95_fraction": 0.23529411764705882, + "action_abs_median": 0.0034719131131487613, + "action_delta": { + "distinct_n": 15, + "max": 0.055523423944476596, + "min": -0.04103743978705223, + "n": 17 + }, + "action_signs": { + "consistency": 0.5714285714285714, + "negative": 6, + "positive": 8, + "zero": 3 + }, + "effect_to_repeat_median": 3.2771966527196663, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.0010594155557517443, + "repeat_abs_p95": 0.031925759090416374, + "repeat_delta": { + "distinct_n": 21, + "max": 0.02168109668109668, + "min": -0.03201970443349754, + "n": 29 + } + }, + "graph_padding_fraction": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.002483113089604908, + "action_delta": { + "distinct_n": 17, + "max": 0.21027653696749515, + "min": -0.2241759801940655, + "n": 17 + }, + "action_signs": { + "consistency": 0.5625, + "negative": 7, + "positive": 9, + "zero": 1 + }, + "effect_to_repeat_median": 0.07674048944322485, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.032357274596769375, + "repeat_abs_p95": 0.24385677131445133, + "repeat_delta": { + "distinct_n": 29, + "max": 0.26242965569766435, + "min": -0.18173061839089436, + "n": 29 + } + }, + "kv_usage_end_minus_start": { + "action_above_repeat_p95_fraction": 0.23529411764705882, + "action_abs_median": 7.313298449929118e-05, + "action_delta": { + "distinct_n": 17, + "max": 0.08863131728902607, + "min": -0.006308261401860582, + "n": 17 + }, + "action_signs": { + "consistency": 0.8823529411764706, + "negative": 2, + "positive": 15, + "zero": 0 + }, + "effect_to_repeat_median": 1.4692416585900228, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 4.977600796418624e-05, + "repeat_abs_p95": 0.03241204552355029, + "repeat_delta": { + "distinct_n": 14, + "max": 0.048360614955967995, + "min": -0.03483866016958903, + "n": 29 + } + }, + "kv_usage_max": { + "action_above_repeat_p95_fraction": 0.29411764705882354, + "action_abs_median": 0.0029570125473361575, + "action_delta": { + "distinct_n": 16, + "max": 0.08590208433411406, + "min": -0.0029570125473361575, + "n": 17 + }, + "action_signs": { + "consistency": 0.8823529411764706, + "negative": 2, + "positive": 15, + "zero": 0 + }, + "effect_to_repeat_median": null, + "effect_to_repeat_median_is_infinite": true, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.0, + "repeat_abs_p95": 0.016674847306688556, + "repeat_delta": { + "distinct_n": 14, + "max": 0.004527588437235774, + "min": -0.018634334752970383, + "n": 29 + } + }, + "kv_usage_mean": { + "action_above_repeat_p95_fraction": 0.11764705882352941, + "action_abs_median": 0.0013514937493694472, + "action_delta": { + "distinct_n": 17, + "max": 0.04101485276318234, + "min": -0.0013514937493694472, + "n": 17 + }, + "action_signs": { + "consistency": 0.7058823529411765, + "negative": 5, + "positive": 12, + "zero": 0 + }, + "effect_to_repeat_median": 2.827343009345717, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.0004780084145793828, + "repeat_abs_p95": 0.006592699934625479, + "repeat_delta": { + "distinct_n": 29, + "max": 0.004456117360644808, + "min": -0.006626073152505554, + "n": 29 + } + }, + "preemptions": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.0, + "action_delta": { + "distinct_n": 1, + "max": 0.0, + "min": 0.0, + "n": 17 + }, + "action_signs": { + "consistency": 0.0, + "negative": 0, + "positive": 0, + "zero": 17 + }, + "effect_to_repeat_median": 0.0, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": false, + "qualifies": false, + "repeat_abs_median": 0.0, + "repeat_abs_p95": 0.0, + "repeat_delta": { + "distinct_n": 1, + "max": 0.0, + "min": 0.0, + "n": 29 + } + }, + "prefill_token_fraction": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.0001483422608830054, + "action_delta": { + "distinct_n": 16, + "max": 0.8861120723274618, + "min": -0.7248910361224853, + "n": 17 + }, + "action_signs": { + "consistency": 0.6, + "negative": 6, + "positive": 9, + "zero": 2 + }, + "effect_to_repeat_median": 0.0009890369063830554, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.1499865777764538, + "repeat_abs_p95": 0.9129144795909149, + "repeat_delta": { + "distinct_n": 28, + "max": 0.8754134325195487, + "min": -0.9129695381069503, + "n": 29 + } + }, + "queue_running_mean": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 0.27085744499999986, + "action_delta": { + "distinct_n": 17, + "max": 3.8361017661999997, + "min": -0.7297395955999999, + "n": 17 + }, + "action_signs": { + "consistency": 0.6470588235294118, + "negative": 6, + "positive": 11, + "zero": 0 + }, + "effect_to_repeat_median": 2.6248225517066213, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.10319076419999984, + "repeat_abs_p95": 6.572392109320001, + "repeat_delta": { + "distinct_n": 29, + "max": 0.07105187159999993, + "min": -6.5953128982, + "n": 29 + } + }, + "queue_waiting_mean": { + "action_above_repeat_p95_fraction": 0.23529411764705882, + "action_abs_median": 0.0, + "action_delta": { + "distinct_n": 7, + "max": 0.0, + "min": -3.4976107514, + "n": 17 + }, + "action_signs": { + "consistency": 1.0, + "negative": 6, + "positive": 0, + "zero": 11 + }, + "effect_to_repeat_median": 0.0, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 0.0, + "repeat_abs_p95": 0.10560919299999999, + "repeat_delta": { + "distinct_n": 5, + "max": 0.0, + "min": -1.5032174162, + "n": 29 + } + }, + "scheduler_steps_per_s": { + "action_above_repeat_p95_fraction": 0.0, + "action_abs_median": 4.200000000000017, + "action_delta": { + "distinct_n": 15, + "max": 59.80000000000001, + "min": -84.2, + "n": 17 + }, + "action_signs": { + "consistency": 0.6666666666666666, + "negative": 10, + "positive": 5, + "zero": 2 + }, + "effect_to_repeat_median": 2.333333333333365, + "effect_to_repeat_median_is_infinite": false, + "gate_feature": true, + "qualifies": false, + "repeat_abs_median": 1.799999999999983, + "repeat_abs_p95": 101.72, + "repeat_delta": { + "distinct_n": 24, + "max": 101.8, + "min": -31.799999999999997, + "n": 29 + } + } + }, + "horizon_s": 5.0, + "qualifying_features": [], + "repeats": [ + { + "delta_state": { + "batch_size.mean": -0.11342809216915306, + "batch_tokens.mean": -4.816915335040164, + "decode_batch_size.mean": -0.11215679350225116, + "graph_full_share": 0.0011653571113269257, + "graph_none_share": -0.0010594155557517443, + "graph_padding_fraction": -0.0002394644309091495, + "kv_usage_end_minus_start": 4.977600796418624e-05, + "kv_usage_max": -4.977600796418624e-05, + "kv_usage_mean": -0.002650866963514159, + "preemptions": 0.0, + "prefill_token_fraction": -0.00016947847485904166, + "queue_running_mean": -0.21751143979999998, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 1.2000000000000028 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.25, + "request_hash": "26629995f38f2c013d5aa5e4b9d7344311ab1f951c9d83e68212c67ca8076fda", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp1_mns16/anchor-0.25/result.json" + }, + "target": { + "cell": "tp1_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp1_mns16/confirm-1-anchor-0.25/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.01603319151928506, + "batch_tokens.mean": 0.7965437220913429, + "decode_batch_size.mean": 0.015822228472979205, + "graph_full_share": -0.00019338279244751622, + "graph_none_share": 0.00017580253858866246, + "graph_padding_fraction": -2.1621324535013326e-05, + "kv_usage_end_minus_start": -4.982561036370736e-05, + "kv_usage_max": 0.0, + "kv_usage_mean": 0.0010437773534030942, + "preemptions": 0.0, + "prefill_token_fraction": 4.236776766430861e-05, + "queue_running_mean": 0.07105187159999993, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -0.19999999999999574 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.24609375, + "request_hash": "7e48c6bfc00eeadd6011111170c31123fb117c9fa75c18ccc8d8d505fd7fcff3", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.24609375/result.json" + }, + "target": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/confirm-1-anchor-0.24609375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.012605042016806678, + "batch_tokens.mean": 0.012605042016787138, + "decode_batch_size.mean": 0.012605042016806678, + "graph_full_share": 0.0, + "graph_none_share": 0.0, + "graph_padding_fraction": 0.00010847307953028382, + "kv_usage_end_minus_start": 4.982561036370736e-05, + "kv_usage_max": 0.0, + "kv_usage_mean": 0.00017122409391133464, + "preemptions": 0.0, + "prefill_token_fraction": -6.355303957206182e-05, + "queue_running_mean": 0.01412161399999956, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.0 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.25, + "request_hash": "26629995f38f2c013d5aa5e4b9d7344311ab1f951c9d83e68212c67ca8076fda", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/anchor-0.25/result.json" + }, + "target": { + "cell": "tp1_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp1_mns32/confirm-1-anchor-0.25/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.06534997517906493, + "batch_tokens.mean": -2.426725054960656, + "decode_batch_size.mean": -0.06471172257286728, + "graph_full_share": 0.0005850648890149968, + "graph_none_share": -0.000531877171831785, + "graph_padding_fraction": -0.00034778464236925486, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": -4.995504046367838e-05, + "kv_usage_mean": -0.0014804826259866288, + "preemptions": 0.0, + "prefill_token_fraction": -4.237146928010027e-05, + "queue_running_mean": -0.14321269680000004, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.5999999999999943 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.24609375, + "request_hash": "7e48c6bfc00eeadd6011111170c31123fb117c9fa75c18ccc8d8d505fd7fcff3", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp1_mns64/anchor-0.24609375/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp1_mns64/confirm-1-anchor-0.24609375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.060654008438818074, + "batch_tokens.mean": -2.402267932489451, + "decode_batch_size.mean": -0.06002109704641434, + "graph_full_share": 0.0005801687763713481, + "graph_none_share": -0.0005274261603375532, + "graph_padding_fraction": -0.00017401096415257163, + "kv_usage_end_minus_start": 4.995504046356736e-05, + "kv_usage_max": -4.995504046367838e-05, + "kv_usage_mean": -0.0013647646656208823, + "preemptions": 0.0, + "prefill_token_fraction": -6.355303957206182e-05, + "queue_running_mean": -0.09758093800000012, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.6000000000000014 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.25, + "request_hash": "26629995f38f2c013d5aa5e4b9d7344311ab1f951c9d83e68212c67ca8076fda", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp1_mns64/anchor-0.25/result.json" + }, + "target": { + "cell": "tp1_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp1_mns64/confirm-1-anchor-0.25/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.9280844155844155, + "batch_tokens.mean": 100.79992784992785, + "decode_batch_size.mean": 0.9185245310245311, + "graph_full_share": -0.009559884559884546, + "graph_none_share": 0.02168109668109668, + "graph_padding_fraction": -0.18173061839089436, + "kv_usage_end_minus_start": 0.048360614955967995, + "kv_usage_max": 0.004527588437235774, + "kv_usage_mean": 0.004456117360644808, + "preemptions": 0.0, + "prefill_token_fraction": 0.8754134325195487, + "queue_running_mean": -0.277960427, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -31.799999999999997 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.2265625, + "request_hash": "a05848006335fc9f595432bab793a13d427244886e4f04e51ba74d495453ef90", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.9920634920634921, + "mns": 8, + "trial_id": "tp1_mns8/anchor-0.2265625/result.json" + }, + "target": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.9920634920634921, + "mns": 8, + "trial_id": "tp1_mns8/confirm-1-anchor-0.2265625/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.013264036958066772, + "batch_tokens.mean": 0.31208244491826065, + "decode_batch_size.mean": 0.013175195451314625, + "graph_full_share": -8.884150675192437e-05, + "graph_none_share": 8.88415067519556e-05, + "graph_padding_fraction": 5.628150611948664e-05, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": 6.337324494750524e-05, + "preemptions": 0.0, + "prefill_token_fraction": -2.779388529827731e-05, + "queue_running_mean": 0.007332840999999757, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": -0.20000000000000284 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.23046875, + "request_hash": "0f4c973153935c8abcd421eb631900670e31af0dc8a33bdf7e4d3d85e7ed7711", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.9923076923076923, + "mns": 8, + "trial_id": "tp1_mns8/anchor-0.23046875/result.json" + }, + "target": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.9923076923076923, + "mns": 8, + "trial_id": "tp1_mns8/confirm-1-anchor-0.23046875/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.01133760879523571, + "batch_tokens.mean": -0.4460948236371962, + "decode_batch_size.mean": -0.011211635364177575, + "graph_full_share": 0.00012597343105813508, + "graph_none_share": -0.0001259734310581767, + "graph_padding_fraction": 2.5032232616357952e-05, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -2.595429314883324e-06, + "preemptions": 0.0, + "prefill_token_fraction": -2.465132225659694e-05, + "queue_running_mean": -0.0003634421999998416, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.20000000000000284 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.234375, + "request_hash": "14d2a74fffe25e7d9b3e7490c392eae0dc31bb1f3fe6566c9c0a567543bdd6ac", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.9924242424242424, + "mns": 8, + "trial_id": "tp1_mns8/anchor-0.234375/result.json" + }, + "target": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.9924242424242424, + "mns": 8, + "trial_id": "tp1_mns8/confirm-1-anchor-0.234375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.03836578028285853, + "batch_tokens.mean": -2.3411943704830662, + "decode_batch_size.mean": -0.037743352121442975, + "graph_full_share": 0.0005705591479649996, + "graph_none_share": -0.0005705591479650066, + "graph_padding_fraction": 8.67237650413492e-05, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -0.00012192636323195283, + "preemptions": 0.0, + "prefill_token_fraction": -0.00016953030936628366, + "queue_running_mean": -0.0205579666000002, + "queue_waiting_mean": -0.0408831314, + "scheduler_steps_per_s": 0.6000000000000014 + }, + "descriptive_full_outcome": { + "delta_pass_rate": -0.006993006993006978, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.25, + "request_hash": "26629995f38f2c013d5aa5e4b9d7344311ab1f951c9d83e68212c67ca8076fda", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 1 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.958041958041958, + "mns": 8, + "trial_id": "tp1_mns8/anchor-0.25/result.json" + }, + "target": { + "cell": "tp1_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.951048951048951, + "mns": 8, + "trial_id": "tp1_mns8/confirm-1-anchor-0.25/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.2758963500935341, + "batch_tokens.mean": -16.135882715276434, + "decode_batch_size.mean": -0.2723042461451284, + "graph_full_share": 0.0035921039484052564, + "graph_none_share": -0.0048721071863581, + "graph_padding_fraction": 0.10945908199689197, + "kv_usage_end_minus_start": -0.004480240988461115, + "kv_usage_max": 0.0, + "kv_usage_mean": -0.0010388280544342795, + "preemptions": 0.0, + "prefill_token_fraction": -0.7696270176402451, + "queue_running_mean": -0.36681181659999984, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 28.400000000000006 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.49609375, + "request_hash": "a78992ce59bb3b857a7ef8844e0a690ea9dd529a659cf5edd599b63fef8b6a80", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp2_mns16/anchor-0.49609375/result.json" + }, + "target": { + "cell": "tp2_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp2_mns16/confirm-1-anchor-0.49609375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.006385050186775487, + "batch_tokens.mean": -0.006810792236799035, + "decode_batch_size.mean": -0.006341827643625564, + "graph_full_share": 4.322254314959029e-05, + "graph_none_share": 0.0, + "graph_padding_fraction": -0.0016266700040674653, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -1.7558597020827724e-05, + "preemptions": 0.0, + "prefill_token_fraction": 3.0428082455902228e-05, + "queue_running_mean": -0.0059703380000000195, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.4000000000000057 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.5, + "request_hash": "3160017dbd8249f711eb115f1e72ddbb37eab3a3333a48762cc3104e94bd2f15", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp2_mns16/anchor-0.5/result.json" + }, + "target": { + "cell": "tp2_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp2_mns16/confirm-1-anchor-0.5/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.006361323155215537, + "batch_tokens.mean": -0.006361323155216425, + "decode_batch_size.mean": -0.006361323155215537, + "graph_full_share": 0.0, + "graph_none_share": 0.0, + "graph_padding_fraction": -0.0018169528035430205, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -2.673005121892058e-05, + "preemptions": 0.0, + "prefill_token_fraction": 0.0001139335897381577, + "queue_running_mean": -0.008856016399999334, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.0 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.75, + "request_hash": "4f4c792e90f5c1bf33978fea26debcadfce5f8b872a31be86a88a1bf6b09a21c", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp2_mns32/anchor-0.75/result.json" + }, + "target": { + "cell": "tp2_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp2_mns32/confirm-1-anchor-0.75/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.36334379104298975, + "batch_tokens.mean": -99.4815933746712, + "decode_batch_size.mean": 0.38174161358586733, + "graph_full_share": 0.015964732518547464, + "graph_none_share": -0.019464720194647202, + "graph_padding_fraction": 0.26242965569766435, + "kv_usage_end_minus_start": -0.024225165055486664, + "kv_usage_max": -0.013153357937349175, + "kv_usage_mean": -0.006611009430699675, + "preemptions": 0.0, + "prefill_token_fraction": -0.8730961888774497, + "queue_running_mean": -2.3594406332, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 55.999999999999986 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.7385786802030457, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.75390625, + "request_hash": "2677a6a12ff0e104d6246dd121d0667ff4fe3d25f8d68699547906420246ebdd", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.20558375634517767, + "mns": 32, + "trial_id": "tp2_mns32/anchor-0.75390625/result.json" + }, + "target": { + "cell": "tp2_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.9441624365482234, + "mns": 32, + "trial_id": "tp2_mns32/confirm-1-anchor-0.75390625/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.008984926990108555, + "batch_tokens.mean": -0.009617608016100565, + "decode_batch_size.mean": -0.00892069541386542, + "graph_full_share": 6.42315762428014e-05, + "graph_none_share": 0.0, + "graph_padding_fraction": -0.00023488823078426924, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -3.459821231118886e-05, + "preemptions": 0.0, + "prefill_token_fraction": 3.0382556995986465e-05, + "queue_running_mean": -0.01180635799999985, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.5999999999999943 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.5, + "request_hash": "3160017dbd8249f711eb115f1e72ddbb37eab3a3333a48762cc3104e94bd2f15", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp2_mns64/anchor-0.5/result.json" + }, + "target": { + "cell": "tp2_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp2_mns64/confirm-1-anchor-0.5/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.36810601285071254, + "batch_tokens.mean": -111.9216322174668, + "decode_batch_size.mean": -0.3386389524789051, + "graph_full_share": 0.025109761896862537, + "graph_none_share": -0.026143790849673203, + "graph_padding_fraction": 0.22131844466419573, + "kv_usage_end_minus_start": -0.03483866016958903, + "kv_usage_max": -0.018634334752970383, + "kv_usage_mean": -0.006551218139822743, + "preemptions": 0.0, + "prefill_token_fraction": -0.8766852234122235, + "queue_running_mean": -2.0965550011999996, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 65.8 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.6624040920716113, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.75, + "request_hash": "4f4c792e90f5c1bf33978fea26debcadfce5f8b872a31be86a88a1bf6b09a21c", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.23017902813299232, + "mns": 64, + "trial_id": "tp2_mns64/anchor-0.75/result.json" + }, + "target": { + "cell": "tp2_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.8925831202046036, + "mns": 64, + "trial_id": "tp2_mns64/confirm-1-anchor-0.75/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.017777364465908274, + "batch_tokens.mean": -0.019283121886095156, + "decode_batch_size.mean": -0.017624495692285524, + "graph_full_share": 0.0001528687736229717, + "graph_none_share": -4.586063208690105e-05, + "graph_padding_fraction": -0.0033762430254597187, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -3.866481934330576e-05, + "preemptions": 0.0, + "prefill_token_fraction": -3.0428082455902228e-05, + "queue_running_mean": -0.01706728199999974, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 1.200000000000017 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.4921875, + "request_hash": "cd227aee3be472a35e8c35af60a44a1411c4dc689cbd98746b3fb8a8d329b44c", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "trial_id": "tp2_mns8/anchor-0.4921875/result.json" + }, + "target": { + "cell": "tp2_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "trial_id": "tp2_mns8/confirm-1-anchor-0.4921875/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.373100622158411, + "batch_tokens.mean": -19.752101280210574, + "decode_batch_size.mean": -0.36846434553720986, + "graph_full_share": 0.004636276621201252, + "graph_none_share": -0.006318796362766213, + "graph_padding_fraction": 0.13466522306023426, + "kv_usage_end_minus_start": -0.004491915827622761, + "kv_usage_max": 0.0, + "kv_usage_mean": -0.0010760794618353137, + "preemptions": 0.0, + "prefill_token_fraction": -0.7698627933477863, + "queue_running_mean": -0.3758000022000001, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 24.799999999999983 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.6190476190476191, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.49609375, + "request_hash": "a78992ce59bb3b857a7ef8844e0a690ea9dd529a659cf5edd599b63fef8b6a80", + "study_sha256": "9474f0d0b53579f1db852ca68abfb0b96ba43ae4e17738118bf8e3209eb09ece", + "tp": 2 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp2_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.27106227106227104, + "mns": 8, + "trial_id": "tp2_mns8/anchor-0.49609375/result.json" + }, + "target": { + "cell": "tp2_mns8", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.8901098901098901, + "mns": 8, + "trial_id": "tp2_mns8/confirm-1-anchor-0.49609375/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.035790047012957515, + "batch_tokens.mean": -0.037904196766425535, + "decode_batch_size.mean": -0.03550338263960562, + "graph_full_share": -0.0008241600733860377, + "graph_none_share": 0.0, + "graph_padding_fraction": -0.002233730654183863, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": -1.0202155715566263e-05, + "kv_usage_mean": -4.688019669552533e-05, + "preemptions": 0.0, + "prefill_token_fraction": 0.0, + "queue_running_mean": -0.04172862040000069, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 1.1999999999999886 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.2469565217391304, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.033182214016, + "request_hash": "e6b624a0212807df3733c54b4a2160fba24f19ca4776b14f34918d83428bba7f", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.7530434782608696, + "mns": 16, + "trial_id": "tp4_mns16/anchor-0.033182214016/result.json" + }, + "target": { + "cell": "tp4_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp4_mns16/confirm-1-anchor-0.033182214016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.31521561989075764, + "batch_tokens.mean": -113.69135049600723, + "decode_batch_size.mean": -0.2948443636019542, + "graph_full_share": 0.013747312308444393, + "graph_none_share": -0.02466367713004484, + "graph_padding_fraction": 0.2327910644295707, + "kv_usage_end_minus_start": -0.014762519320332457, + "kv_usage_max": -0.002734177731754772, + "kv_usage_mean": -0.003886883143649442, + "preemptions": 0.0, + "prefill_token_fraction": -0.8857303498661139, + "queue_running_mean": -3.9262134145999994, + "queue_waiting_mean": -1.5032174162, + "scheduler_steps_per_s": 81.39999999999999 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.34982935153583616, + "feasibility_transition": "false->false" + }, + "group": { + "anchor": 0.033717411016, + "request_hash": "472a874ecc0e844b5b36a715bbc309b63e73074d39327cd734869f76721d71db", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.06313993174061433, + "mns": 16, + "trial_id": "tp4_mns16/anchor-0.033717411016/result.json" + }, + "target": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.4129692832764505, + "mns": 16, + "trial_id": "tp4_mns16/confirm-1-anchor-0.033717411016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.0565950637806516, + "batch_tokens.mean": -1.2259074371774261, + "decode_batch_size.mean": -0.05612473435097076, + "graph_full_share": -0.0006731434430105043, + "graph_none_share": -0.0011210762331838565, + "graph_padding_fraction": 0.03352610055520758, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -8.342130161142786e-05, + "preemptions": 0.0, + "prefill_token_fraction": -0.1499865777764538, + "queue_running_mean": -0.07804562620000066, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 1.799999999999983 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.034252608017, + "request_hash": "21c1f3b7d972b19c952a894863a70d1e85bd0e24a7e7b6b0fcc088360d0e01bd", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp4_mns16/anchor-0.034252608017/result.json" + }, + "target": { + "cell": "tp4_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp4_mns16/confirm-1-anchor-0.034252608017/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.017452685323813277, + "batch_tokens.mean": -0.018160486007140264, + "decode_batch_size.mean": -0.01735671234980174, + "graph_full_share": 8.877500095971769e-05, + "graph_none_share": 0.0, + "graph_padding_fraction": 0.0015546681503931792, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": -5.101077857783132e-06, + "kv_usage_mean": -2.2530897596876806e-05, + "preemptions": 0.0, + "prefill_token_fraction": 5.993471374250714e-05, + "queue_running_mean": -0.021152762000000713, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 0.4000000000000057 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.2469565217391304, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.033182214016, + "request_hash": "e6b624a0212807df3733c54b4a2160fba24f19ca4776b14f34918d83428bba7f", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns16", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.7530434782608696, + "mns": 16, + "trial_id": "tp4_mns16/anchor-0.033182214016/result.json" + }, + "target": { + "cell": "tp4_mns16", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 16, + "trial_id": "tp4_mns16/confirm-2-anchor-0.033182214016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.16723437281046838, + "batch_tokens.mean": -213.3770035894838, + "decode_batch_size.mean": 0.2293820267109341, + "graph_full_share": 0.029853079087214685, + "graph_none_share": -0.03201970443349754, + "graph_padding_fraction": 0.24386359763484056, + "kv_usage_end_minus_start": -0.02873466386876411, + "kv_usage_max": -0.01666487968508279, + "kv_usage_mean": -0.006565235690514186, + "preemptions": 0.0, + "prefill_token_fraction": -0.9129695381069503, + "queue_running_mean": -6.573865443400001, + "queue_waiting_mean": -0.105609193, + "scheduler_steps_per_s": 101.60000000000001 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.9692832764505119, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.033717411016, + "request_hash": "472a874ecc0e844b5b36a715bbc309b63e73074d39327cd734869f76721d71db", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.030716723549488054, + "mns": 32, + "trial_id": "tp4_mns32/anchor-0.033717411016/result.json" + }, + "target": { + "cell": "tp4_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp4_mns32/confirm-1-anchor-0.033717411016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.06700882459564284, + "batch_tokens.mean": -1.237066033004087, + "decode_batch_size.mean": -0.06643525070889744, + "graph_full_share": -0.0005748153886646623, + "graph_none_share": -0.0011210762331838565, + "graph_padding_fraction": 0.032357274596769375, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": -5.1056616682254585e-06, + "kv_usage_mean": -0.00010377856500988665, + "preemptions": 0.0, + "prefill_token_fraction": -0.15007350008784556, + "queue_running_mean": -0.10319076419999984, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 2.1999999999999886 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.034252608017, + "request_hash": "21c1f3b7d972b19c952a894863a70d1e85bd0e24a7e7b6b0fcc088360d0e01bd", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp4_mns32/anchor-0.034252608017/result.json" + }, + "target": { + "cell": "tp4_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp4_mns32/confirm-1-anchor-0.034252608017/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.16017120245497818, + "batch_tokens.mean": -213.38441949985196, + "decode_batch_size.mean": 0.22236668550970418, + "graph_full_share": 0.029898516783762652, + "graph_none_share": -0.03201970443349754, + "graph_padding_fraction": 0.2419788945317641, + "kv_usage_end_minus_start": -0.02873466386876411, + "kv_usage_max": -0.016659774023414564, + "kv_usage_mean": -0.006562301403937485, + "preemptions": 0.0, + "prefill_token_fraction": -0.9129575557004137, + "queue_running_mean": -6.570182108200001, + "queue_waiting_mean": -0.105609193, + "scheduler_steps_per_s": 101.8 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.9692832764505119, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.033717411016, + "request_hash": "472a874ecc0e844b5b36a715bbc309b63e73074d39327cd734869f76721d71db", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns32", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.030716723549488054, + "mns": 32, + "trial_id": "tp4_mns32/anchor-0.033717411016/result.json" + }, + "target": { + "cell": "tp4_mns32", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 32, + "trial_id": "tp4_mns32/confirm-2-anchor-0.033717411016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.5328616639627084, + "batch_tokens.mean": -211.42080067637045, + "decode_batch_size.mean": 0.5912671663277198, + "graph_full_share": 0.027680346411352086, + "graph_none_share": -0.03178484107579462, + "graph_padding_fraction": 0.23688813872052464, + "kv_usage_end_minus_start": -0.028772123554492213, + "kv_usage_max": -0.016661043117286778, + "kv_usage_mean": -0.006272675400456023, + "preemptions": 0.0, + "prefill_token_fraction": -0.912693798885484, + "queue_running_mean": -6.2424369058, + "queue_waiting_mean": -0.10551258, + "scheduler_steps_per_s": 89.39999999999999 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.8430034129692833, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.033717411016, + "request_hash": "472a874ecc0e844b5b36a715bbc309b63e73074d39327cd734869f76721d71db", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.11433447098976109, + "mns": 64, + "trial_id": "tp4_mns64/anchor-0.033717411016/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 0.9573378839590444, + "mns": 64, + "trial_id": "tp4_mns64/confirm-1-anchor-0.033717411016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.08536723607223529, + "batch_tokens.mean": -1.2605052275442308, + "decode_batch_size.mean": -0.08463476949102322, + "graph_full_share": 0.0006975872202020783, + "graph_none_share": -0.0011248593925759281, + "graph_padding_fraction": 0.034272917448908424, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -0.00010935706758585708, + "preemptions": 0.0, + "prefill_token_fraction": -0.15010635693287294, + "queue_running_mean": -0.10249850960000018, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 2.799999999999983 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.034252608017, + "request_hash": "21c1f3b7d972b19c952a894863a70d1e85bd0e24a7e7b6b0fcc088360d0e01bd", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp4_mns64/anchor-0.034252608017/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp4_mns64/confirm-1-anchor-0.034252608017/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": 0.1540235762873472, + "batch_tokens.mean": -211.8229141697429, + "decode_batch_size.mean": 0.21558506586552006, + "graph_full_share": 0.029510309964790093, + "graph_none_share": -0.03178484107579462, + "graph_padding_fraction": 0.24384653183386754, + "kv_usage_end_minus_start": -0.028772123554492213, + "kv_usage_max": -0.016681492387759067, + "kv_usage_mean": -0.006626073152505554, + "preemptions": 0.0, + "prefill_token_fraction": -0.9128498654266666, + "queue_running_mean": -6.5953128982, + "queue_waiting_mean": -0.10551258, + "scheduler_steps_per_s": 101.8 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.8856655290102389, + "feasibility_transition": "false->true" + }, + "group": { + "anchor": 0.033717411016, + "request_hash": "472a874ecc0e844b5b36a715bbc309b63e73074d39327cd734869f76721d71db", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns64", + "early_stopped": true, + "full_feasible": false, + "full_pass_rate": 0.11433447098976109, + "mns": 64, + "trial_id": "tp4_mns64/anchor-0.033717411016/result.json" + }, + "target": { + "cell": "tp4_mns64", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 64, + "trial_id": "tp4_mns64/confirm-2-anchor-0.033717411016/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.3497477888336098, + "batch_tokens.mean": -19.68794568822554, + "decode_batch_size.mean": -0.3465001381978996, + "graph_full_share": 0.004242675511332172, + "graph_none_share": -0.004954394693200663, + "graph_padding_fraction": 0.14768569288462857, + "kv_usage_end_minus_start": -0.0007955733482928329, + "kv_usage_max": 0.0, + "kv_usage_mean": -0.0004780084145793828, + "preemptions": 0.0, + "prefill_token_fraction": -0.8110422816759224, + "queue_running_mean": -0.41782893040000024, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 28.19999999999999 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.016591107009, + "request_hash": "2407501cda53bf9c761c448dc50ab4780b4a55958cc00ba1b19cd09de1cf73e1", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "trial_id": "tp4_mns8/anchor-0.016591107009/result.json" + }, + "target": { + "cell": "tp4_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "trial_id": "tp4_mns8/confirm-1-anchor-0.016591107009/result.json" + } + }, + { + "delta_state": { + "batch_size.mean": -0.060037523452157515, + "batch_tokens.mean": -3.365563298490128, + "decode_batch_size.mean": -0.05956848030018724, + "graph_full_share": 0.0004467077637808625, + "graph_none_share": -0.000982757080318056, + "graph_padding_fraction": 0.07118473038433726, + "kv_usage_end_minus_start": 0.0, + "kv_usage_max": 0.0, + "kv_usage_mean": -6.376841981488128e-05, + "preemptions": 0.0, + "prefill_token_fraction": -0.5189516489461117, + "queue_running_mean": -0.1074558633999998, + "queue_waiting_mean": 0.0, + "scheduler_steps_per_s": 5.200000000000017 + }, + "descriptive_full_outcome": { + "delta_pass_rate": 0.0, + "feasibility_transition": "true->true" + }, + "group": { + "anchor": 0.017126304009, + "request_hash": "93cd99ebf2a760cc440dce0cb7e51273686dcfbfb07650d27e9e16d2ff1d2eed", + "study_sha256": "76e9d642ba9570917cfeeea848ed92f27904e87760eedabd48805b84e82eca26", + "tp": 4 + }, + "kind": "same_config_repeat", + "source": { + "cell": "tp4_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "trial_id": "tp4_mns8/anchor-0.017126304009/result.json" + }, + "target": { + "cell": "tp4_mns8", + "early_stopped": false, + "full_feasible": true, + "full_pass_rate": 1.0, + "mns": 8, + "trial_id": "tp4_mns8/confirm-1-anchor-0.017126304009/result.json" + } + } + ], + "sanity": { + "action_pairs": 17, + "distinct_action_vectors": 17, + "invariants": { + "all_pair_hashes_match": true, + "all_values_finite": true, + "expected_action_pair_count": true, + "nonnegative_counters": true, + "ratios_bounded": true, + "state_vectors_not_all_identical": true, + "sufficient_repeat_pair_count": true + }, + "red_flags": [], + "repeat_pairs": 29, + "trials": 66 + } + } + }, + "provenance": { + "analysis_script": "/home/gahow/phd/aituner/runs/intervention-response-v0/analyze_phase6.py", + "analysis_script_sha256": "f1b40c350f22e797b08b129df7b55386b407bd5ae7f466d36987e94d768ded2f", + "phase6_metrics": "/home/gahow/phd/aituner/runs/opprof-phase6/phase6/metrics.json", + "phase6_metrics_sha256": "290ba7fcb8727291166de7e4d47afdc84e230052495c81dd087db0ace9f93a16", + "raw_root": "/home/gahow/phd/aituner/runs/opprof-phase6/phase6/solo-authoritative/cells", + "streams": [ + { + "bytes": 12745297, + "path": "runs/opprof-phase6/phase6/solo-authoritative/cells/tp1_mns16/opprof/opprof-v1-dp0-pid2781473-1783876972093434233.jsonl", + "sha256": "265932302b079d1ad81febc4a345f87ac2a3e00118e63bf5873b92d61146d3b8" + }, + { + "bytes": 20018398, + "path": "runs/opprof-phase6/phase6/solo-authoritative/cells/tp1_mns32/opprof/opprof-v1-dp0-pid2786356-1783877278912197439.jsonl", + "sha256": "552bb3961893ab20760e95a6148a24387df544370ca2cb3af052fa87a7ef79f6" + }, + { + "bytes": 19825716, + "path": "runs/opprof-phase6/phase6/solo-authoritative/cells/tp1_mns64/opprof/opprof-v1-dp0-pid2795014-1783877830485564578.jsonl", + "sha256": "f07f2beed8ffcd695665edba931cd5824f10f4ef678064ac09d5a0d9b96acf50" + }, + { + "bytes": 38381207, + "path": "runs/opprof-phase6/phase6/solo-authoritative/cells/tp1_mns8/opprof/opprof-v1-dp0-pid2770271-1783876258461072221.jsonl", + "sha256": "f3758f599bd58952d039eae3cc7a1b6abe3372e82fe15aff38d8f27bedf0cbef" + }, + { + "bytes": 42681418, + "path": "runs/opprof-phase6/phase6/solo-authoritative/cells/tp2_mns16/opprof/opprof-v1-dp0-pid2755628-1783875389707263062.jsonl", + "sha256": "e56faa0ceb0f750ad781b04a0fa86388a8fd4acdff4503fb40064bbb43b8a4de" + }, + { + "bytes": 20701713, + "path": "runs/opprof-phase6/phase6/solo-authoritative/cells/tp2_mns32/opprof/opprof-v1-dp0-pid2730662-1783873935616837232.jsonl", + "sha256": "ab1070348c976491ff5ad4905ab172678f692598810ca72a0dbab824f3bb491a" + }, + { + "bytes": 24186851, + "path": "runs/opprof-phase6/phase6/solo-authoritative/cells/tp2_mns64/opprof/opprof-v1-dp0-pid2736153-1783874256706634444.jsonl", + "sha256": "c8d7582674a9ff3cba8363a93672b96977082f6f2eb595aee0ea41012e85978e" + }, + { + "bytes": 25542356, + "path": "runs/opprof-phase6/phase6/solo-authoritative/cells/tp2_mns8/opprof/opprof-v1-dp0-pid2750298-1783875076865595283.jsonl", + "sha256": "ad006affdccb0c9cf2ae97938810a7f232ed0517086d3e20772aa461930f8518" + }, + { + "bytes": 50625291, + "path": "runs/opprof-phase6/phase6/solo-authoritative/cells/tp4_mns16/opprof/opprof-v1-dp0-pid2741574-1783874579483097755.jsonl", + "sha256": "4443a0f159f23242445e48c846e45e29b3647012734edeff2678bcf75b008ada" + }, + { + "bytes": 34980126, + "path": "runs/opprof-phase6/phase6/solo-authoritative/cells/tp4_mns32/opprof/opprof-v1-dp0-pid2712385-1783873000008589576.jsonl", + "sha256": "445b190a5392df7aa05555de33a550d6401d739bc9000494af650671db4c63c9" + }, + { + "bytes": 34066572, + "path": "runs/opprof-phase6/phase6/solo-authoritative/cells/tp4_mns64/opprof/opprof-v1-dp0-pid2721119-1783873467764669604.jsonl", + "sha256": "ddc7bf89342fe7fececc68b6c6be988816abd1ff37dfc63c8c2a55f7b9a96f44" + }, + { + "bytes": 52957710, + "path": "runs/opprof-phase6/phase6/solo-authoritative/cells/tp4_mns8/opprof/opprof-v1-dp0-pid2762505-1783875811578126796.jsonl", + "sha256": "ffdbfe671cecc166ea718ff0c31f7a15f788dcc2da64d6b4ee10fc16d489a849" + } + ] + }, + "sanity": { + "red_flags": [], + "stream_bytes": { + "distinct_n": 12, + "max": 52957710.0, + "min": 12745297.0, + "n": 12 + }, + "stream_count": 12 + }, + "schema": "intervention-response-audit-v0", + "stable_qualifying_features": [], + "status": "COMPLETE" +} diff --git a/runs/intervention-response-v0/test_analysis.py b/runs/intervention-response-v0/test_analysis.py new file mode 100644 index 0000000..74ada8c --- /dev/null +++ b/runs/intervention-response-v0/test_analysis.py @@ -0,0 +1,57 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import importlib.util +import math +from pathlib import Path + + +HERE = Path(__file__).resolve().parent + + +def load_module(): + spec = importlib.util.spec_from_file_location( + "intervention_response_v0", HERE / "analyze_phase6.py" + ) + module = importlib.util.module_from_spec(spec) + assert spec.loader is not None + spec.loader.exec_module(module) + return module + + +def pair(module, delta: dict[str, float]) -> dict[str, object]: + state = {feature: 0.0 for feature in module.ALL_FEATURES} + state.update(delta) + return {"delta_state": state} + + +def main() -> None: + module = load_module() + assert module.numeric([0.0, 1.0, 1.0]) == { + "n": 3, + "min": 0.0, + "max": 1.0, + "distinct_n": 2, + } + assert math.isclose(module.quantile([0.0, 10.0], 0.95), 9.5) + + actions = [ + pair(module, {"queue_waiting_mean": -1.0 - 0.1 * index}) + for index in range(8) + ] + repeats = [ + pair(module, {"queue_waiting_mean": 0.01 * ((index % 3) - 1)}) + for index in range(20) + ] + stats = module.response_statistics(actions, repeats) + waiting = stats["queue_waiting_mean"] + assert waiting["qualifies"] + assert waiting["action_signs"]["negative"] == 8 + assert waiting["action_signs"]["consistency"] == 1.0 + assert waiting["effect_to_repeat_median"] > 2.0 + assert not stats["kv_usage_mean"]["qualifies"] + print("intervention response v0 analysis: PASS") + + +if __name__ == "__main__": + main() diff --git a/runs/intervention-response-v0/test_p1_analysis.py b/runs/intervention-response-v0/test_p1_analysis.py new file mode 100644 index 0000000..8a99899 --- /dev/null +++ b/runs/intervention-response-v0/test_p1_analysis.py @@ -0,0 +1,35 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import importlib.util +from pathlib import Path + + +HERE = Path(__file__).resolve().parent + + +def load_module(): + spec = importlib.util.spec_from_file_location( + "intervention_response_p1", HERE / "analyze_p1.py" + ) + module = importlib.util.module_from_spec(spec) + assert spec.loader is not None + spec.loader.exec_module(module) + return module + + +def main() -> None: + module = load_module() + values = [-2.0, -1.0, 1.0, 2.0] + labels = [0, 0, 1, 1] + threshold, direction, balanced = module._fit_threshold(values, labels) + assert direction == 1 + assert -1.0 < threshold < 1.0 + assert balanced == 1.0 + assert module._balanced_accuracy(labels, labels) == 1.0 + assert module._balanced_accuracy(labels, [1, 1, 0, 0]) == 0.0 + print("intervention response P1 confirmation analysis: PASS") + + +if __name__ == "__main__": + main()