| |
| """Rebuild the scaled Weka records without loading a model or tokenizer.""" |
|
|
| import argparse |
| import copy |
| from pathlib import Path |
|
|
| import orjson |
| from huggingface_hub import hf_hub_download |
|
|
| SOURCE = "semianalysisai/cc-traces-weka-062126-256k" |
| REVISION = "8fecd2fc56694469f758f0afbbb6335ad3043740" |
| TOKEN_DIVISOR = 8 |
| TIME_DIVISOR = 8 |
| IDLE_CAP_SECONDS = 1 |
| |
| STREAM_GAP_SECONDS = 3600 |
| OUTPUT_LIMIT = 10_000 |
| MODIFICATION_NOTICE = ( |
| f"Modified for agentx-mini from {SOURCE}@{REVISION}, published by SemiAnalysis " |
| "under Apache-2.0. Token lengths scaled by 8; timeline compressed with long " |
| "stream-separation gaps retained; sessions filtered to fewer than 10,000 " |
| "requested output tokens. See README.md for details and LICENSE for terms." |
| ) |
|
|
|
|
| def requests(trace): |
| for entry in trace["requests"]: |
| yield from entry["requests"] if entry["type"] == "subagent" else (entry,) |
|
|
|
|
| def make_timeline(calls): |
| """Use one shared clock; retain long gaps that identify separate streams.""" |
| intervals = sorted((r["t"], r["t"] + r["api_time"]) for r in calls) |
| origin, end = intervals[0] |
| gaps = [] |
| for start, stop in intervals[1:]: |
| if start > end: |
| gaps.append((end, start)) |
| end = max(end, stop) |
|
|
| def timeline(seconds): |
| value = (seconds - origin) / TIME_DIVISOR |
| for start, end in gaps: |
| if seconds <= start: |
| break |
| original_width = end - start |
| scaled_width = original_width / TIME_DIVISOR |
| if original_width > STREAM_GAP_SECONDS: |
| |
| target_width = min(original_width, STREAM_GAP_SECONDS + 1) |
| else: |
| target_width = min(scaled_width, IDLE_CAP_SECONDS) |
| fraction = min(seconds - start, original_width) / original_width |
| value -= fraction * (scaled_width - target_width) |
| return value |
|
|
| return timeline |
|
|
|
|
| def scale_prefix(entry): |
| |
| tools, system = entry.get("tool_tokens", 0), entry.get("system_tokens", 0) |
| scaled_tools = (tools + TOKEN_DIVISOR - 1) // TOKEN_DIVISOR |
| total = (tools + system + TOKEN_DIVISOR - 1) // TOKEN_DIVISOR |
| if "tool_tokens" in entry: |
| entry["tool_tokens"] = scaled_tools |
| if "system_tokens" in entry: |
| entry["system_tokens"] = total - scaled_tools |
|
|
|
|
| def distill_trace(raw): |
| calls = list(requests(raw)) |
| requested_output = sum(max(1, (r["out"] + TOKEN_DIVISOR - 1) // TOKEN_DIVISOR) for r in calls) |
| if requested_output >= OUTPUT_LIMIT: |
| return None |
| block_size = raw["block_size"] |
| if block_size % TOKEN_DIVISOR or any(r["in"] != len(r["hash_ids"]) * block_size for r in calls): |
| raise ValueError("Expected complete hash blocks divisible by the token scale") |
| timeline = make_timeline(calls) |
|
|
| def duration(start, seconds): |
| return max(0.0, timeline(start + seconds) - timeline(start)) |
|
|
| trace = copy.deepcopy(raw) |
| trace.pop("totals", None) |
| trace["block_size"] = block_size // TOKEN_DIVISOR |
| scale_prefix(trace) |
| for request in requests(trace): |
| request["in"] //= TOKEN_DIVISOR |
| request["out"] = (request["out"] + TOKEN_DIVISOR - 1) // TOKEN_DIVISOR |
| start = request["t"] |
| request["t"] = timeline(start) |
| request["api_time"] = duration(start, request["api_time"]) |
| if request.get("ttft") is not None: |
| request["ttft"] = duration(start, request["ttft"]) |
| if request.get("think_time") is not None: |
| think = request["think_time"] |
| request["think_time"] = duration(start - think, think) |
| for entry in trace["requests"]: |
| scale_prefix(entry) |
| if entry["type"] == "subagent": |
| start = entry["t"] |
| entry["t"] = timeline(start) |
| if entry.get("duration_ms") is not None: |
| |
| end = start + entry["duration_ms"] / 1000 |
| entry["duration_ms"] = round( |
| max(0.0, timeline(end) * 1000 - timeline(start) * 1000) |
| ) |
| entry["total_tokens"] = sum(r["in"] + r["out"] for r in entry["requests"]) |
| |
| |
| calls = list(requests(trace)) |
| trace["totals"] = { |
| "input_tokens": sum(r["in"] for r in calls), |
| "output_tokens": sum(r["out"] for r in calls), |
| "modification_notice": MODIFICATION_NOTICE, |
| } |
| return trace |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "--input", type=Path, help="Original traces.jsonl; otherwise download the pinned HF source" |
| ) |
| parser.add_argument("--output", type=Path, required=True, help="New output directory") |
| args = parser.parse_args() |
| source = args.input or Path( |
| hf_hub_download(SOURCE, "traces.jsonl", repo_type="dataset", revision=REVISION) |
| ) |
| args.output.mkdir(parents=True, exist_ok=False) |
| count = 0 |
| with source.open("rb") as inputs, (args.output / "traces.jsonl").open("wb") as output: |
| for line in inputs: |
| trace = distill_trace(orjson.loads(line)) |
| if trace is not None: |
| output.write(orjson.dumps(trace) + b"\n") |
| count += 1 |
| print(f"Wrote {count} sessions to {args.output / 'traces.jsonl'}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
