From 74c95e5817babe1f2906a7a4ed88f0e23c67d4da Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Sun, 27 Sep 2026 20:08:06 +0800 Subject: [PATCH 01/26] Add Cua-S1 multimodal CUDA worker and parity recipe --- .github/workflows/cua-s1-multimodal.yml | 30 + .gitignore | 7 + README.md | 8 +- recipe/cua_s1/README.md | 145 +++++ recipe/cua_s1/check_frontend.py | 62 ++ recipe/cua_s1/download_weights.py | 33 ++ recipe/cua_s1/evaluate_multimodal.py | 321 +++++++++++ recipe/cua_s1/experiments/README.md | 111 ++++ .../cua_s1/experiments/rtx4090/benchmark.json | 409 +++++++++++++ .../cua_s1/experiments/rtx4090/candidate.json | 536 ++++++++++++++++++ .../cua_s1/experiments/rtx4090/frontend.json | 79 +++ .../cua_s1/experiments/rtx4090/packages.txt | 62 ++ .../cua_s1/experiments/rtx4090/reference.json | 527 +++++++++++++++++ recipe/cua_s1/make_example.py | 71 +++ recipe/cua_s1/requirements-multimodal.txt | 11 + .../cua_s1/multimodal/THIRD_PARTY_NOTICES.md | 21 + src/models/cua_s1/multimodal/model.py | 164 ++++++ src/models/cua_s1/multimodal/protocol.py | 217 +++++++ src/models/cua_s1/multimodal/server.py | 128 +++++ .../cua_s1/multimodal/weights.lock.json | 102 ++++ tests/cua_s1/test_evaluation.py | 48 ++ tests/cua_s1/test_model.py | 112 ++++ tests/cua_s1/test_protocol.py | 156 +++++ tests/cua_s1/test_server.py | 85 +++ 24 files changed, 3442 insertions(+), 3 deletions(-) create mode 100644 .github/workflows/cua-s1-multimodal.yml create mode 100644 recipe/cua_s1/README.md create mode 100644 recipe/cua_s1/check_frontend.py create mode 100644 recipe/cua_s1/download_weights.py create mode 100644 recipe/cua_s1/evaluate_multimodal.py create mode 100644 recipe/cua_s1/experiments/README.md create mode 100644 recipe/cua_s1/experiments/rtx4090/benchmark.json create mode 100644 recipe/cua_s1/experiments/rtx4090/candidate.json create mode 100644 recipe/cua_s1/experiments/rtx4090/frontend.json create mode 100644 recipe/cua_s1/experiments/rtx4090/packages.txt create mode 100644 recipe/cua_s1/experiments/rtx4090/reference.json create mode 100644 recipe/cua_s1/make_example.py create mode 100644 recipe/cua_s1/requirements-multimodal.txt create mode 100644 src/models/cua_s1/multimodal/THIRD_PARTY_NOTICES.md create mode 100644 src/models/cua_s1/multimodal/model.py create mode 100644 src/models/cua_s1/multimodal/protocol.py create mode 100644 src/models/cua_s1/multimodal/server.py create mode 100644 src/models/cua_s1/multimodal/weights.lock.json create mode 100644 tests/cua_s1/test_evaluation.py create mode 100644 tests/cua_s1/test_model.py create mode 100644 tests/cua_s1/test_protocol.py create mode 100644 tests/cua_s1/test_server.py diff --git a/.github/workflows/cua-s1-multimodal.yml b/.github/workflows/cua-s1-multimodal.yml new file mode 100644 index 0000000..9329244 --- /dev/null +++ b/.github/workflows/cua-s1-multimodal.yml @@ -0,0 +1,30 @@ +name: Cua-S1 multimodal CPU checks +on: + pull_request: + paths: + - 'src/models/cua_s1/multimodal/**' + - 'tests/cua_s1/**' + - 'recipe/cua_s1/**' + - '.github/workflows/cua-s1-multimodal.yml' + push: + branches: [main] + paths: + - 'src/models/cua_s1/multimodal/**' + - 'tests/cua_s1/**' + - 'recipe/cua_s1/**' + - '.github/workflows/cua-s1-multimodal.yml' +permissions: + contents: read +jobs: + cpu: + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - run: python -m pip install Pillow==11.3.0 pytest==9.1.1 ruff==0.16.8 + - run: PYTHONPATH=src python -m pytest tests/cua_s1 -q + - run: ruff check --isolated --select E4,E7,E9,F,I src/models/cua_s1/multimodal tests/cua_s1 recipe/cua_s1 + - run: ruff format --isolated --check src/models/cua_s1/multimodal tests/cua_s1 recipe/cua_s1 diff --git a/.gitignore b/.gitignore index ad67955..a2db644 100644 --- a/.gitignore +++ b/.gitignore @@ -19,3 +19,10 @@ target # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ + +# Python workers and local model artifacts +__pycache__/ +.pytest_cache/ +.ruff_cache/ +.venv/ +weights/ diff --git a/README.md b/README.md index 6cc42ab..7fe790f 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ A community-maintained inference engine for prefill-only System1-Omni models, designed around a Rust frontend, model-owned execution, and high-performance CUDA and Metal backends. -The project is in its initial design stage. The architecture below describes the intended implementation; model engines and GPU backends are not implemented yet. +The project is in early development. A Cua-S1 multimodal worker has been validated on CUDA through Transformers and PEFT; the architecture below describes the intended native frontend and backend organization. ## Architecture @@ -27,20 +27,22 @@ Implementation code lives under `src/`; recipes and documentation stay at the re | --- | --- | | [`src/frontend/`](src/frontend/) | Rust serving code and the small engine interface. | | [`src/models/laya/`](src/models/laya/) | LAYA preprocessing, batching, state, execution, and output processing. | +| [`src/models/cua_s1/multimodal/`](src/models/cua_s1/multimodal/) | Cua-S1 screenshot preprocessing, multimodal LoRA execution, and choice probabilities. | | [`src/backends/cuda/`](src/backends/cuda/) | NVIDIA GPU operations and kernel integration. | | [`src/backends/metal/`](src/backends/metal/) | Apple GPU operations and kernel integration. | | [`recipe/`](recipe/) | Model setup instructions, launch commands, configuration examples, and example requests. | | [`docs/`](docs/) | Project documentation and architecture assets. | -These directories currently document ownership; implementations will be added incrementally. They do not prescribe process boundaries. Shared utilities will be extracted when concrete implementations need them. +These directories document ownership; implementations are being added incrementally. They do not prescribe process boundaries. Shared utilities will be extracted when concrete implementations need them. ## Supported models -No models are implemented yet. LAYA is the first planned model: +Validated coverage is listed by modality and execution path: | Model | Status | | --- | --- | | LAYA | Planned | +| [Cua-S1 4B 0.2](recipe/cua_s1/README.md) | Multimodal screenshot choices via Transformers/PEFT on RTX 4090 CUDA; [parity and measurements](recipe/cua_s1/experiments/README.md). Text serving, native CUDA kernels and Metal deferred. | CUDA and Metal coverage will be documented per model as implementations are added and validated. diff --git a/recipe/cua_s1/README.md b/recipe/cua_s1/README.md new file mode 100644 index 0000000..6f175ad --- /dev/null +++ b/recipe/cua_s1/README.md @@ -0,0 +1,145 @@ +# Cua-S1 0.2 multimodal CUDA worker + +This recipe adds screenshot decisions using the multimodal adapter discussed in +[#10](https://github.com/ThinkFlowLab/system1-omni/issues/10). It loads Transformers +and PEFT directly. Upstream `FourBModel` is used only as an independent parity +oracle. The worker owns image decoding, the processor/chat template, vision and +language LoRA loading, and the candidate-letter probability readout. + +The text mapping and pinned revisions follow +[PR #11](https://github.com/ThinkFlowLab/system1-omni/pull/11). The image `state` +format below is this PR's proposed extension. A separately launched multimodal +worker uses the same request model name; deployment routing selects its modality. + +## Setup + +Run from this repository's root on Linux with an NVIDIA GPU. The measured CUDA +wheel, driver, GPU memory and results are recorded in [experiments](experiments/README.md). +Python 3.12 is required by the pinned environment. + +```sh +python3.12 -m venv .venv +. .venv/bin/activate +pip install -r recipe/cua_s1/requirements-multimodal.txt +PYTHONPATH=src python recipe/cua_s1/download_weights.py --dest weights +PYTHONPATH=src python -m models.cua_s1.multimodal.server \ + --base weights/Qwen3.5-4B \ + --adapter weights/cua-s1-4b-0.2/multimodal +``` + +`weights.lock.json` pins and checks every loaded artifact's size and SHA-256. +Extra files are rejected, except Hugging Face's `.cache` metadata, so another +checkpoint cannot silently override verified shards. Downloads require roughly +9 GB plus cache/install space. Loading is offline after the download completes. +Weights are not included in this repository. + +The worker binds to `127.0.0.1:8000` only after loading and a successful warmup. +`GET /health` returns `{"status":"ready","modality":"multimodal"}`. One request +runs at a time; concurrent requests return `503`. This is a loopback model worker, +with the Rust frontend and an ingress responsible for public serving. + +To use the Rust frontend when [PR #2](https://github.com/ThinkFlowLab/system1-omni/pull/2) +is available in your checkout: + +```sh +cargo build --release --locked +OMNI_JEV_BIND=127.0.0.1:8080 \ +OMNI_JEV_BACKEND_URL=http://127.0.0.1:8000 ./target/release/omni-jev +``` + +## Request and response + +Generate a self-contained example with a synthetic settings screenshot: + +```sh +python recipe/cua_s1/make_example.py --output /tmp/cua-example.json +curl -sS http://127.0.0.1:8000/v1/systemone \ + -H 'Content-Type: application/json' --data-binary @/tmp/cua-example.json +``` + +Replace the port with `8080` to send the same request through the frontend. +The request shape is: + +```json +{ + "model": "cua-s1-4b-0.2", + "state": {"image": "data:image/png;base64,"}, + "questions": { + "next": { + "type": "choice", + "instructions": "Save the changes", + "criteria": {"save": "Save changes", "cancel": "Cancel"} + } + } +} +``` + +- `state` contains exactly one inline PNG or JPEG data URL. Images are decoded to + RGB. Local filenames, remote URLs, video, animation and mixed text/image state + are unsupported. +- There are 1–8 questions and 1–26 options per question. Option order assigns + letters A–Z. Labels are strings, objects, arrays or `null` (which uses the key). + Structured values use Python `json.dumps(..., ensure_ascii=False)` followed by + the upstream chooser's label escaping. Instructions accept strings, objects + or arrays; an omitted/empty instruction omits the goal block. +- Limits: 8 MiB body, 4 MiB decoded image, 2048 pixels per side, 1,048,576 pixels + total, 16,384 characters per question and 4096 processed tokens per question. + Every question is validated/preprocessed before any forward pass begins. +- `<|image_pad|>`, `<|video_pad|>`, `<|vision_start|>` and `<|vision_end|>` are + rejected in user text because the processor interprets them as media controls. + Other special-token spellings retain upstream tokenization behavior. +- Empty/invalid inputs, duplicate JSON keys, unsupported models and `score`/`noul` + questions return `422`. Oversized bodies return `413`; chunked uploads return + `411`. Send `Content-Length` and `Content-Type: application/json`. + +Each answer has `type`, `choice`, `probabilities` and `confidence`. The readout +uses the last position's candidate-letter logits, casts to fp32 and applies +softmax over those letters only. There is no decode. Ties select the earliest +option; confidence is `1 - H(p)/ln(n)`, or 1 for one option. Each question has a +separate forward pass over the same screenshot. Usage sums processed input tokens +and reports zero output tokens. + +Response identity: +`cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal`. +The base is BF16; PEFT's rank-16, alpha-32 adapter remains unmerged with fp32 LoRA +branches, including 50 vision projection modules (178 total adapted modules). + +## Reproduce correctness and profiling + +```sh +git clone https://github.com/trycua/cua.git /tmp/cua-reference +git -C /tmp/cua-reference checkout 0e75660ce4c2edda519e0c795fa3ad98abf4e76f +for mode in reference candidate benchmark; do + PYTHONPATH=src python recipe/cua_s1/evaluate_multimodal.py \ + --weights weights --reference /tmp/cua-reference \ + --output /tmp/cua-evidence --mode "$mode" +done +``` + +The evaluator hashes the pinned `four_b.py` before importing it and checks report +provenance/environment before comparison. Reference and candidate are separate +processes to avoid keeping two models in GPU memory. Eight synthetic requests +(nine question forwards) cover two resolutions, PNG/JPEG, 1/26 candidates, +structured/Unicode labels, special-token text and multiple questions. It requires +identical processor tensor shapes/dtypes/hashes and identical fp32 candidate +probabilities; numerical tolerance is zero. These are integration/parity fixtures, +not an evaluation of GUI task success. + +Benchmark mode records two runs of 50 serial requests after five warmups on the +640×480 fixture, with synchronized end-to-end engine latency, p50/p95, serial +throughput, allocated/reserved GPU peaks and a separate operator profile. Load +and warmup are recorded separately; candidate load time includes artifact hash +verification. See the experiment report for measured scope and limitations. + +CPU-only validation: + +```sh +pip install Pillow==11.3.0 pytest==9.1.1 ruff==0.16.8 +PYTHONPATH=src python -m pytest tests/cua_s1 -q +ruff check --select E4,E7,E9,F,I src/models/cua_s1/multimodal recipe/cua_s1/*.py tests/cua_s1 +ruff format --check src/models/cua_s1/multimodal recipe/cua_s1/*.py tests/cua_s1 +``` + +Metal, native CUDA kernels, text-adapter serving, batching, caching and training +are outside this worker's scope. This implementation does not import or modify +another contributor's text engine. diff --git a/recipe/cua_s1/check_frontend.py b/recipe/cua_s1/check_frontend.py new file mode 100644 index 0000000..b2ae0fe --- /dev/null +++ b/recipe/cua_s1/check_frontend.py @@ -0,0 +1,62 @@ +"""Compare HTTP response status, content type and bytes through Rust and directly.""" + +import argparse +import hashlib +import json +import urllib.error +import urllib.request +from pathlib import Path + + +def exchange(base, route, body=None): + request = urllib.request.Request( + base.rstrip("/") + route, + data=body, + headers={"Content-Type": "application/json"}, + ) + try: + response = urllib.request.urlopen(request, timeout=60) + except urllib.error.HTTPError as exc: + response = exc + with response: + return response.status, response.headers.get("Content-Type"), response.read() + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--worker", default="http://127.0.0.1:8000") + parser.add_argument("--frontend", default="http://127.0.0.1:8080") + parser.add_argument("--fixtures", type=Path, required=True) + parser.add_argument("--output", type=Path, required=True) + args = parser.parse_args() + checks = [("health", "/health", None)] + checks += [ + (p.stem, "/v1/systemone", p.read_bytes()) + for p in sorted(args.fixtures.glob("*.json")) + ] + checks += [ + ("invalid", "/v1/systemone", b"{}"), + ("duplicate", "/v1/systemone", b'{"model":1,"model":2}'), + ] + report = [] + for name, route, body in checks: + direct = exchange(args.worker, route, body) + proxied = exchange(args.frontend, route, body) + assert direct == proxied, f"frontend changed response: {name}" + expected_status = 422 if name in {"invalid", "duplicate"} else 200 + assert direct[0] == expected_status, f"unexpected status: {name}: {direct[0]}" + report.append( + { + "name": name, + "status": direct[0], + "content_type": direct[1], + "body_sha256": hashlib.sha256(direct[2]).hexdigest(), + "identical": True, + } + ) + print(f"{name}: HTTP {direct[0]}, identical response", flush=True) + args.output.write_text(json.dumps(report, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/recipe/cua_s1/download_weights.py b/recipe/cua_s1/download_weights.py new file mode 100644 index 0000000..104b393 --- /dev/null +++ b/recipe/cua_s1/download_weights.py @@ -0,0 +1,33 @@ +"""Download the upstream-pinned artifacts and verify their checksums.""" + +import argparse +import json +from pathlib import Path + +from huggingface_hub import snapshot_download + +from models.cua_s1.multimodal.model import verify_weights + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--dest", type=Path, required=True) + args = parser.parse_args() + lock = ( + Path(__file__).resolve().parents[2] + / "src/models/cua_s1/multimodal/weights.lock.json" + ) + for artifact in json.loads(lock.read_text())["artifacts"]: + snapshot_download( + repo_id=artifact["repo_id"], + revision=artifact["revision"], + local_dir=args.dest / artifact["name"], + allow_patterns=list(artifact["files"]), + token=False, + ) + verify_weights(args.dest / "Qwen3.5-4B", args.dest / "cua-s1-4b-0.2/multimodal") + print("Pinned base and multimodal adapter checksums verified.") + + +if __name__ == "__main__": + main() diff --git a/recipe/cua_s1/evaluate_multimodal.py b/recipe/cua_s1/evaluate_multimodal.py new file mode 100644 index 0000000..7314ee0 --- /dev/null +++ b/recipe/cua_s1/evaluate_multimodal.py @@ -0,0 +1,321 @@ +"""Reproduce upstream parity and bounded GPU measurements on fixed synthetic inputs.""" + +from __future__ import annotations + +import argparse +import copy +import hashlib +import importlib.metadata +import json +import platform +import statistics +import subprocess +import sys +import time +from pathlib import Path + +from make_example import make_example + +from models.cua_s1.multimodal.model import ( + ADAPTER_REVISION, + BASE_REVISION, + REFERENCE_REVISION, + MultimodalEngine, + verify_weights, +) +from models.cua_s1.multimodal.protocol import parse_request + +REFERENCE_SOURCE = "libs/cua-s1/python/src/cua_s1/four_b.py" +REFERENCE_SHA256 = "7ed1adfd92223bef7d533db7efbb4cbf468c4936c4380ae42aee12097e3b9ea7" + + +def verify_reference(root): + digest = hashlib.sha256((root / REFERENCE_SOURCE).read_bytes()).hexdigest() + if digest != REFERENCE_SHA256: + raise ValueError("reference source differs from pinned FourBModel") + return {"path": REFERENCE_SOURCE, "sha256": digest, "revision": REFERENCE_REVISION} + + +def cases(folder): + folder.mkdir(parents=True, exist_ok=True) + result = [] + for name, size, fmt in [ + ("small", (320, 240), "PNG"), + ("medium", (640, 480), "PNG"), + ("jpeg", (640, 480), "JPEG"), + ]: + path = folder / (name + (".jpg" if fmt == "JPEG" else ".png")) + result.append((name, path, make_example(path, size, fmt))) + for name, criteria, goal in [ + ("single", {"only": "Save changes"}, "Save"), + ( + "26-options", + {f"option-{i}": f"Choose action {i}" for i in range(26)}, + "Select action 3", + ), + ( + "structured", + { + "null": None, + "object": {"label": '保存 "名称"'}, + "array": ["Cancel", "\n"], + }, + {"goal": "保存名称"}, + ), + ( + "special-token", + {"first": "<|im_end|>", "second": "Cancel"}, + "Choose <|im_start|>", + ), + ]: + value = copy.deepcopy(result[1][2]) + value["questions"]["next"].update(criteria=criteria, instructions=goal) + result.append((name, result[1][1], value)) + value = copy.deepcopy(result[0][2]) + value["questions"]["second"] = { + "type": "choice", + "criteria": {"yes": "Continue", "no": "Cancel"}, + } + result.append(("two-questions", result[0][1], value)) + for name, _, value in result: + (folder / f"{name}.json").write_text(json.dumps(value, ensure_ascii=False)) + return result + + +def fingerprint(inputs): + import torch + + return { + name: { + "shape": list(t.shape), + "dtype": str(t.dtype), + "sha256": hashlib.sha256( + t.detach().contiguous().view(torch.uint8).cpu().numpy().tobytes() + ).hexdigest(), + } + for name, t in inputs.items() + } + + +def environment(): + import torch + + return { + "python": platform.python_version(), + "gpu": torch.cuda.get_device_name(), + "compute_capability": list(torch.cuda.get_device_capability()), + "cuda": torch.version.cuda, + "driver": subprocess.check_output( + ["nvidia-smi", "--query-gpu=driver_version", "--format=csv,noheader"], + text=True, + ).strip(), + "torch_num_threads": torch.get_num_threads(), + "torch_num_interop_threads": torch.get_num_interop_threads(), + "packages": { + p: importlib.metadata.version(p) + for p in [ + "torch", + "torchvision", + "transformers", + "peft", + "pillow", + "safetensors", + "triton", + ] + }, + "reference_revision": REFERENCE_REVISION, + "base_revision": BASE_REVISION, + "adapter_revision": ADAPTER_REVISION, + "dtype": "bfloat16", + "adapter_merged": False, + } + + +def measure(call): + import torch + + torch.cuda.synchronize() + start = time.perf_counter() + result = call() + torch.cuda.synchronize() + return result, (time.perf_counter() - start) * 1000 + + +def quantiles(values): + ordered = sorted(values) + return { + "p50_ms": statistics.median(values), + "p95_ms": ordered[max(0, __import__("math").ceil(0.95 * len(values)) - 1)], + } + + +def main(): + import torch + + p = argparse.ArgumentParser(description=__doc__) + p.add_argument("--weights", type=Path, required=True) + p.add_argument( + "--reference", type=Path, required=True, help="checkout of pinned trycua/cua" + ) + p.add_argument("--output", type=Path, required=True) + p.add_argument( + "--mode", choices=["reference", "candidate", "benchmark"], required=True + ) + args = p.parse_args() + args.output.mkdir(parents=True, exist_ok=True) + base = str(args.weights / "Qwen3.5-4B") + adapter = str(args.weights / "cua-s1-4b-0.2/multimodal") + fixture_set = cases(args.output / "fixtures") + report = {"environment": environment(), "mode": args.mode, "cases": []} + report["reference_source"] = verify_reference(args.reference) + if args.mode == "reference": + _, report["artifact_verification_ms"] = measure( + lambda: verify_weights(Path(base), Path(adapter)) + ) + sys.path.insert(0, str(args.reference / "libs/cua-s1/python/src")) + from cua_s1.four_b import FourBModel, Option, assign_letters, build_prompt + + model = FourBModel( + base_model=base, lora_adapter_path=adapter, modality="multimodal" + ) + _, report["load_ms"] = measure(model.load) + first = True + for name, path, value in fixture_set: + request = parse_request(value) + for q in request.questions: + options = [ + Option(element_id=k, role="Decision", label=v, action="select") + for k, v in zip(q.keys, q.labels) + ] + messages = build_prompt( + assign_letters(options), + app="Cua Driver", + task_family="closed-candidate decision", + screenshot=path, + modality="multimodal", + goal=q.goal, + ) + text = model._processor.apply_chat_template( + messages, tokenize=False, add_generation_prompt=True + ) + inputs = model._processor( + text=[text], images=[request.image], return_tensors="pt" + ) + + def call(): + return model.forward( + options, + app="Cua Driver", + task_family="closed-candidate decision", + screenshot=path, + goal=q.goal, + ) + + if first: + _, report["warmup_ms"] = measure(call) + first = False + output, elapsed = measure(call) + report["cases"].append( + { + "name": name, + "question": q.name, + "inputs": fingerprint(inputs), + "probabilities": [x.probability for x in output], + "latency_ms": elapsed, + } + ) + print(f"reference {name}/{q.name}: {elapsed:.1f} ms", flush=True) + else: + engine, report["load_ms"] = measure(lambda: MultimodalEngine(base, adapter)) + _, report["warmup_ms"] = measure(engine.warmup) + report["adapter_modules"] = engine.adapter_modules + if args.mode == "candidate": + reference = json.loads((args.output / "reference.json").read_text()) + if ( + reference["reference_source"] != report["reference_source"] + or reference["environment"] != report["environment"] + ): + raise ValueError("reference provenance or environment mismatch") + expected = {(x["name"], x["question"]): x for x in reference["cases"]} + for name, _, value in fixture_set: + request = parse_request(value) + for q in request.questions: + inputs = engine.prepare(request.image, q) + probabilities, elapsed = measure(lambda: engine.score(inputs, q)) + ref = expected[name, q.name] + difference = max( + abs(a - b) for a, b in zip(ref["probabilities"], probabilities) + ) + assert fingerprint(inputs) == ref["inputs"], ( + f"preprocessing mismatch: {name}" + ) + assert probabilities == ref["probabilities"], ( + f"probability mismatch: {name}: {difference}" + ) + report["cases"].append( + { + "name": name, + "question": q.name, + "inputs": fingerprint(inputs), + "probabilities": probabilities, + "max_abs_difference": difference, + "latency_ms": elapsed, + } + ) + print(f"candidate {name}/{q.name}: exact parity", flush=True) + else: + request = parse_request(fixture_set[1][2]) + for _ in range(5): + engine.predict(request) + report["benchmark"] = { + "case": "medium", + "batch_size": 1, + "concurrency": 1, + "warmup_requests": 5, + "runs": [], + } + for run in range(2): + torch.cuda.reset_peak_memory_stats() + latencies = [ + measure(lambda: engine.predict(request))[1] for _ in range(50) + ] + report["benchmark"]["runs"].append( + { + "run": run + 1, + "latencies_ms": latencies, + **quantiles(latencies), + "requests_per_second_serial": 1000 / statistics.mean(latencies), + "peak_allocated_bytes": torch.cuda.max_memory_allocated(), + "peak_reserved_bytes": torch.cuda.max_memory_reserved(), + } + ) + print(f"benchmark run {run + 1}: {quantiles(latencies)}", flush=True) + with torch.profiler.profile( + activities=[ + torch.profiler.ProfilerActivity.CPU, + torch.profiler.ProfilerActivity.CUDA, + ], + record_shapes=True, + ) as prof: + engine.predict(request) + torch.cuda.synchronize() + report["profile"] = [ + { + "op": x.key, + "count": x.count, + "device_time_us": x.device_time_total, + "self_device_time_us": x.self_device_time_total, + "cpu_time_us": x.cpu_time_total, + "self_cpu_time_us": x.self_cpu_time_total, + } + for x in sorted( + prof.key_averages(), key=lambda x: x.device_time_total, reverse=True + )[:30] + ] + report["peak_allocated_bytes"] = torch.cuda.max_memory_allocated() + (args.output / f"{args.mode}.json").write_text(json.dumps(report, indent=2)) + print(f"Saved {args.mode}.json", flush=True) + + +if __name__ == "__main__": + main() diff --git a/recipe/cua_s1/experiments/README.md b/recipe/cua_s1/experiments/README.md new file mode 100644 index 0000000..d73403b --- /dev/null +++ b/recipe/cua_s1/experiments/README.md @@ -0,0 +1,111 @@ +# RTX 4090 multimodal validation — 2026-09-27 + +This is a Transformers/PEFT CUDA baseline, with the adapter unmerged and full +logits, for the screenshot worker in [the recipe](../README.md). It does not +implement a native CUDA backend or claim a speedup over upstream. + +## Environment and artifacts + +- One NVIDIA GeForce RTX 4090, 24,564 MiB, compute capability 8.9. +- Ubuntu 22.04 container; NVIDIA driver 595.71.05; PyTorch CUDA runtime 13.0. +- Python 3.12.13; torch 2.14.0, torchvision 0.29.0, Transformers 5.17.0, + PEFT 0.21.0, Pillow 11.3.0, safetensors 0.8.0, Triton 3.8.0. +- PyTorch reported 64 intra-op and 64 inter-op threads; no thread tuning applied. +- BF16 base, PEFT fp32 LoRA branches, no adapter merge, no quantization. +- Neither `flash-linear-attention` nor `causal-conv1d` is installed. The matching + upstream reference uses Transformers' PyTorch fallback implementations. +- All pinned weights passed size and SHA-256 verification. The lock contains + 9,342,907,469 base bytes and 186,638,393 adapter-repository bytes. Only the + `multimodal` adapter is loaded; all 178 target modules, including 50 visual + modules, are required at startup. + +Pinned revisions and the reference-source SHA-256 are present in every JSON +report. Full installed versions are in [packages.txt](rtx4090/packages.txt). +The numerical contract and dependency versions were fixed before comparisons. +No model weights or private screenshots are included. + +## Correctness + +| Check | Result | Evidence | +| --- | --- | --- | +| Processor tensor shapes, dtypes and SHA-256 values | Exact match on 9 question forwards across 8 requests | [reference.json](rtx4090/reference.json), [candidate.json](rtx4090/candidate.json) | +| Candidate fp32 probabilities | Exact match; maximum absolute difference **0** | Same reports | +| Multimodal LoRA attachment | 178 modules, visual modules present | [candidate.json](rtx4090/candidate.json) | +| Rust frontend vs direct worker | All 11 HTTP comparisons passed; status, content type and body bytes identical | [frontend.json](rtx4090/frontend.json) | +| CPU validation | 39 tests passed on local macOS and the Linux GPU host | `tests/cua_s1`, CPU CI workflow | + +Fixtures are generated by `evaluate_multimodal.py` using the pinned Pillow version. +They cover 320×240 and 640×480 screenshots, PNG/JPEG, 1 and 26 candidates, +structured/Unicode labels, special-token spellings and two questions sharing one +image. Processed prompts span 215–752 tokens. Hashes cover input IDs, attention +masks, image pixels and image-grid metadata, rather than just the selected option. +The fixtures establish integration parity, not GUI task accuracy or generalization. + +For the frontend test, PR #2's Rust frontend at +`0c91671ac7c8bd698b957b2c0df921de96e7e628` was built with `cargo build --release --locked` +on macOS. It forwarded to the Linux GPU worker over an SSH tunnel. This exercises +real inference and byte preservation; **network/HTTP latency is not benchmarked**. +Eight valid fixtures, health, malformed envelope and duplicate JSON keys were checked. + +Reproduce the HTTP check after generating the fixtures and starting both servers: + +```sh +python recipe/cua_s1/check_frontend.py \ + --worker http://127.0.0.1:8000 --frontend http://127.0.0.1:8080 \ + --fixtures /tmp/cua-evidence/fixtures --output /tmp/cua-evidence/frontend.json +``` + +## Warm engine performance + +[benchmark.json](rtx4090/benchmark.json) contains every sample and the operator +profile. One 640×480 PNG, three candidates, 456 processed tokens, batch size 1, +concurrency 1; five warmup requests followed by two runs of 50 requests. +`torch.cuda.synchronize()` brackets each measurement. p95 uses nearest rank. + +Timing covers `engine.predict`: chat-template application, processor work, host-to- +device transfer, forward pass, letter readout and answer construction. The request +has already been parsed and its image decoded. JSON parsing, image decoding, +HTTP, queueing, model load, artifact hashing and warmup are excluded. + +| Run | p50 | p95 | Serial throughput | Peak allocated | Peak reserved | +| --- | --- | --- | --- | --- | --- | +| 1 | 126.39 ms | 136.68 ms | 7.79 requests/s | 8.84 GiB | 9.07 GiB | +| 2 | 128.28 ms | 133.01 ms | 7.77 requests/s | 8.84 GiB | 9.07 GiB | + +The parity run's peak allocated memory across all nine forwards was 8.99 GiB. +These bounds describe the measured fixtures, not every request admitted by the +worker's 4096-token limit or a concurrent/batched deployment. + +Measured candidate construction, including weight hashing, was 19.94 s in the +parity process and 18.94 s in the benchmark process. Their initial 224×224 warmups +were 1.82 s and 1.63 s. Upstream load was 16.82 s plus 9.54 s of separately measured +artifact verification; its first 320×240 warmup was 3.67 s. These are individual +observations after importing PyTorch and probing the GPU, with different warmup +shapes and filesystem-cache histories; they are not a cold-start speed comparison. +Per-fixture timings in the parity reports are also single observations; the +reference includes image opening while candidate timing covers `score` only. + +## Profiling and the next optimization boundary + +A separate profiled inference, excluded from the latency samples, reported: + +| Operator | Calls | Self CUDA time | +| --- | --- | --- | +| `aten::mm` | 605 | 35.42 ms | +| `aten::copy_` | 1,642 | 9.55 ms | +| `aten::bmm` | 817 | 9.11 ms | +| `aten::addmm` | 98 | 5.89 ms | +| `aten::mul` | 1,103 | 5.76 ms | + +These are instrumented operator totals, not percentages of request wall time. +The raw profile includes both framework operators and CUDA kernels, which overlap; +do not add parent and child events or add kernel time to its enclosing operator. + +Matrix multiplication dominates the observed operator totals. A subsequent CUDA +optimization should first attribute those GEMMs and copies to vision, language +and LoRA branches using shapes/module ranges, then compare one bounded change +against this baseline. This profile alone does not justify replacing a specific +kernel or claiming a speedup. Gated DeltaNet/causal-convolution backend work should +be coordinated with the text-engine contributor because those language layers are +shared. This PR keeps the exact upstream execution path and contributes the +multimodal correctness and performance baseline needed for that work. diff --git a/recipe/cua_s1/experiments/rtx4090/benchmark.json b/recipe/cua_s1/experiments/rtx4090/benchmark.json new file mode 100644 index 0000000..7b69afc --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090/benchmark.json @@ -0,0 +1,409 @@ +{ + "environment": { + "python": "3.12.13", + "gpu": "NVIDIA GeForce RTX 4090", + "compute_capability": [ + 8, + 9 + ], + "cuda": "13.0", + "driver": "595.71.05", + "torch_num_threads": 64, + "torch_num_interop_threads": 64, + "packages": { + "torch": "2.14.0", + "torchvision": "0.29.0", + "transformers": "5.17.0", + "peft": "0.21.0", + "pillow": "11.3.0", + "safetensors": "0.8.0", + "triton": "3.8.0" + }, + "reference_revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f", + "base_revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", + "adapter_revision": "16818868b0cc7813808aae4e87b417657046ab79", + "dtype": "bfloat16", + "adapter_merged": false + }, + "mode": "benchmark", + "cases": [], + "reference_source": { + "path": "libs/cua-s1/python/src/cua_s1/four_b.py", + "sha256": "7ed1adfd92223bef7d533db7efbb4cbf468c4936c4380ae42aee12097e3b9ea7", + "revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f" + }, + "load_ms": 18941.51310157031, + "warmup_ms": 1633.873094804585, + "adapter_modules": 178, + "benchmark": { + "case": "medium", + "batch_size": 1, + "concurrency": 1, + "warmup_requests": 5, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 125.8343830704689, + 127.36847903579473, + 125.82478113472462, + 125.89417397975922, + 146.41341753304005, + 127.77413055300713, + 127.22665630280972, + 125.83817914128304, + 126.10162515193224, + 127.15142965316772, + 126.42081826925278, + 126.38038955628872, + 126.02570466697216, + 128.5353172570467, + 129.56660240888596, + 129.32745181024075, + 126.28413271158934, + 126.18042714893818, + 133.06267280131578, + 126.3929232954979, + 131.68340362608433, + 126.76465138792992, + 125.68666227161884, + 126.71545054763556, + 125.96531771123409, + 125.74396748095751, + 130.0713624805212, + 132.96419847756624, + 131.16213120520115, + 126.18762347847223, + 125.84684416651726, + 126.00735854357481, + 125.77000726014376, + 126.28292944282293, + 125.9002760052681, + 130.30958734452724, + 136.85170747339725, + 134.48695000261068, + 136.67899277061224, + 134.1363089159131, + 133.8470932096243, + 126.33792497217655, + 126.30761601030827, + 126.43217574805021, + 125.64307544380426, + 125.50272978842258, + 125.40635839104652, + 125.05617458373308, + 125.54042227566242, + 127.74347327649593 + ], + "p50_ms": 126.3866564258933, + "p95_ms": 136.67899277061224, + "requests_per_second_serial": 7.792244462582349, + "peak_allocated_bytes": 9496202240, + "peak_reserved_bytes": 9741271040 + }, + { + "run": 2, + "latencies_ms": [ + 126.58042088150978, + 126.69678498059511, + 126.67341157793999, + 129.0692137554288, + 127.07117944955826, + 129.27887961268425, + 133.4229400381446, + 128.44505812972784, + 127.24453490227461, + 126.93716865032911, + 130.17353229224682, + 131.4986888319254, + 130.03864511847496, + 131.02801516652107, + 129.7577489167452, + 128.6515649408102, + 132.58606754243374, + 128.7766983732581, + 131.9235684350133, + 128.00912745296955, + 127.52761784940958, + 129.2492775246501, + 132.3700835928321, + 128.50904930382967, + 127.91914585977793, + 131.54291920363903, + 129.6907477080822, + 133.75771697610617, + 129.1659427806735, + 126.58135313540697, + 126.16921309381723, + 126.81071180850267, + 128.0105598270893, + 128.40583361685276, + 127.4806559085846, + 127.57191434502602, + 128.10698058456182, + 127.0896615460515, + 127.29146610945463, + 133.00949800759554, + 128.90154495835304, + 128.37096769362688, + 127.91174557060003, + 127.8772447258234, + 128.1898096203804, + 127.69030872732401, + 126.3129971921444, + 129.61805891245604, + 126.81897450238466, + 126.8136901780963 + ], + "p50_ms": 128.28038865700364, + "p95_ms": 133.00949800759554, + "requests_per_second_serial": 7.765628438386997, + "peak_allocated_bytes": 9496202240, + "peak_reserved_bytes": 9741271040 + } + ] + }, + "profile": [ + { + "op": "aten::matmul", + "count": 1422, + "device_time_us": 44527.040000000154, + "self_device_time_us": 0.0, + "cpu_time_us": 53924.26100000019, + "self_cpu_time_us": 9931.453000001111 + }, + { + "op": "aten::linear", + "count": 703, + "device_time_us": 41310.13700000033, + "self_device_time_us": 0.0, + "cpu_time_us": 24486.469999999994, + "self_cpu_time_us": 1650.2199999998538 + }, + { + "op": "aten::mm", + "count": 605, + "device_time_us": 35415.818000000334, + "self_device_time_us": 35415.818000000334, + "cpu_time_us": 13464.22999999985, + "self_cpu_time_us": 8533.79799999894 + }, + { + "op": "ampere_bf16_s1688gemm_bf16_64x128_sliced1x2_ldg8_f2f_tn", + "count": 96, + "device_time_us": 17010.658999999934, + "self_device_time_us": 17010.658999999934, + "cpu_time_us": 0, + "self_cpu_time_us": 0 + }, + { + "op": "aten::copy_", + "count": 1642, + "device_time_us": 9549.038000000242, + "self_device_time_us": 9549.038000000242, + "cpu_time_us": 25915.56300000043, + "self_cpu_time_us": 9625.815000000488 + }, + { + "op": "aten::bmm", + "count": 817, + "device_time_us": 9111.22199999982, + "self_device_time_us": 9109.750999999822, + "cpu_time_us": 20146.271999999823, + "self_cpu_time_us": 16179.460999999617 + }, + { + "op": "ampere_bf16_s1688gemm_bf16_128x128_ldg8_f2f_stages_32x1_tn", + "count": 56, + "device_time_us": 6589.621000000137, + "self_device_time_us": 6589.621000000137, + "cpu_time_us": 0, + "self_cpu_time_us": 0 + }, + { + "op": "aten::addmm", + "count": 98, + "device_time_us": 5894.318999999992, + "self_device_time_us": 5894.318999999992, + "cpu_time_us": 2576.6010000000297, + "self_cpu_time_us": 1777.2650000000776 + }, + { + "op": "aten::mul", + "count": 1103, + "device_time_us": 5763.554999999398, + "self_device_time_us": 5763.554999999398, + "cpu_time_us": 13280.975000000395, + "self_cpu_time_us": 8342.606000000327 + }, + { + "op": "aten::to", + "count": 1361, + "device_time_us": 5300.117000000242, + "self_device_time_us": 0.0, + "cpu_time_us": 28756.462000000047, + "self_cpu_time_us": 1621.334000000551 + }, + { + "op": "aten::_to_copy", + "count": 1080, + "device_time_us": 5300.117000000242, + "self_device_time_us": 0.0, + "cpu_time_us": 27135.127999999495, + "self_cpu_time_us": 4165.844999999095 + }, + { + "op": "ampere_bf16_s16816gemm_bf16_128x64_ldg8_f2f_tn", + "count": 1, + "device_time_us": 4485.06700000001, + "self_device_time_us": 4485.06700000001, + "cpu_time_us": 0, + "self_cpu_time_us": 0 + }, + { + "op": "aten::add", + "count": 1009, + "device_time_us": 4335.962000000129, + "self_device_time_us": 4335.962000000129, + "cpu_time_us": 11608.1780000002, + "self_cpu_time_us": 7166.728000000563 + }, + { + "op": "ampere_bf16_s1688gemm_bf16_128x64_sliced1x2_ldg8_relu_f2f_tn", + "count": 50, + "device_time_us": 3960.761000000013, + "self_device_time_us": 3960.761000000013, + "cpu_time_us": 0, + "self_cpu_time_us": 0 + }, + { + "op": "aten::linalg_solve_triangular", + "count": 48, + "device_time_us": 3340.373000000007, + "self_device_time_us": 2853.693999999952, + "cpu_time_us": 4383.135000000191, + "self_cpu_time_us": 1135.9290000003602 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1})", + "count": 668, + "device_time_us": 3093.801999999436, + "self_device_time_us": 3093.801999999436, + "cpu_time_us": 0, + "self_cpu_time_us": 0 + }, + { + "op": "aten::convolution", + "count": 25, + "device_time_us": 3044.873999999925, + "self_device_time_us": 0.0, + "cpu_time_us": 2021.7800000000425, + "self_cpu_time_us": 143.51700000008714 + }, + { + "op": "aten::_convolution", + "count": 25, + "device_time_us": 3044.873999999925, + "self_device_time_us": 0.0, + "cpu_time_us": 1878.2629999999554, + "self_cpu_time_us": 489.0389999998333 + }, + { + "op": "void batch_trsm_left_kernel(cublasTrsmBatchParams2, float, float const*, int)", + "count": 48, + "device_time_us": 2853.693999999952, + "self_device_time_us": 2853.693999999952, + "cpu_time_us": 0, + "self_cpu_time_us": 0 + }, + { + "op": "ampere_bf16_s1688gemm_bf16_64x64_sliced1x4_ldg8_f2f_tn", + "count": 32, + "device_time_us": 2847.620000000141, + "self_device_time_us": 2847.620000000141, + "cpu_time_us": 0, + "self_cpu_time_us": 0 + }, + { + "op": "aten::clone", + "count": 141, + "device_time_us": 2841.203000000127, + "self_device_time_us": 0.0, + "cpu_time_us": 4514.54400000007, + "self_cpu_time_us": 654.2669999996788 + }, + { + "op": "ampere_sgemm_128x128_tn", + "count": 240, + "device_time_us": 2783.6780000002327, + "self_device_time_us": 2783.6780000002327, + "cpu_time_us": 0, + "self_cpu_time_us": 0 + }, + { + "op": "void at::native::unrolled_elementwise_kernel, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1> >(int, at::native::CUDAFunctor_add, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1>)", + "count": 178, + "device_time_us": 2525.99999999996, + "self_device_time_us": 2525.99999999996, + "cpu_time_us": 0, + "self_cpu_time_us": 0 + }, + { + "op": "ampere_sgemm_128x128_nn", + "count": 192, + "device_time_us": 2428.904999999824, + "self_device_time_us": 2428.904999999824, + "cpu_time_us": 0, + "self_cpu_time_us": 0 + }, + { + "op": "ampere_sgemm_128x128_nt", + "count": 192, + "device_time_us": 2347.072999999873, + "self_device_time_us": 2347.072999999873, + "cpu_time_us": 0, + "self_cpu_time_us": 0 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#12}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#12}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1})", + "count": 112, + "device_time_us": 2314.617000000122, + "self_device_time_us": 2314.617000000122, + "cpu_time_us": 0, + "self_cpu_time_us": 0 + }, + { + "op": "aten::conv1d", + "count": 24, + "device_time_us": 2197.6299999999246, + "self_device_time_us": 0.0, + "cpu_time_us": 1939.474999999984, + "self_cpu_time_us": 93.11899999994057 + }, + { + "op": "aten::scaled_dot_product_attention", + "count": 32, + "device_time_us": 2140.842999999986, + "self_device_time_us": 0.0, + "cpu_time_us": 2570.106999999978, + "self_cpu_time_us": 379.762999999959 + }, + { + "op": "aten::_scaled_dot_product_flash_attention", + "count": 32, + "device_time_us": 2140.842999999986, + "self_device_time_us": 0.0, + "cpu_time_us": 2190.344000000019, + "self_cpu_time_us": 310.61200000015015 + }, + { + "op": "aten::_flash_attention_forward", + "count": 32, + "device_time_us": 2140.842999999986, + "self_device_time_us": 2140.842999999986, + "cpu_time_us": 1620.5300000000316, + "self_cpu_time_us": 539.4930000000277 + } + ], + "peak_allocated_bytes": 9496202240 +} \ No newline at end of file diff --git a/recipe/cua_s1/experiments/rtx4090/candidate.json b/recipe/cua_s1/experiments/rtx4090/candidate.json new file mode 100644 index 0000000..f8e4a92 --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090/candidate.json @@ -0,0 +1,536 @@ +{ + "environment": { + "python": "3.12.13", + "gpu": "NVIDIA GeForce RTX 4090", + "compute_capability": [ + 8, + 9 + ], + "cuda": "13.0", + "driver": "595.71.05", + "torch_num_threads": 64, + "torch_num_interop_threads": 64, + "packages": { + "torch": "2.14.0", + "torchvision": "0.29.0", + "transformers": "5.17.0", + "peft": "0.21.0", + "pillow": "11.3.0", + "safetensors": "0.8.0", + "triton": "3.8.0" + }, + "reference_revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f", + "base_revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", + "adapter_revision": "16818868b0cc7813808aae4e87b417657046ab79", + "dtype": "bfloat16", + "adapter_merged": false + }, + "mode": "candidate", + "cases": [ + { + "name": "small", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + "probabilities": [ + 0.9958575367927551, + 0.0005507932510226965, + 0.003591623157262802 + ], + "max_abs_difference": 0.0, + "latency_ms": 127.26952508091927 + }, + { + "name": "medium", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 0.9958575367927551, + 0.0005507932510226965, + 0.003591623157262802 + ], + "max_abs_difference": 0.0, + "latency_ms": 126.0456619784236 + }, + { + "name": "jpeg", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 0.9936226010322571, + 0.0011634123511612415, + 0.005214052740484476 + ], + "max_abs_difference": 0.0, + "latency_ms": 121.78163509815931 + }, + { + "name": "single", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "c4d7b1102e94984504efa938052a0bba3639ba85f9917de3e8af5426ceefd16b" + }, + "attention_mask": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "3419eb840bd7f9d9e4b1fa6aaea783bae7a4752068701794687337702c2d8968" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "077d91126e88fd3e8ba97a2d8079c28a4d5da388e56c89ca0e584fd5ad4b3641" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 1.0 + ], + "max_abs_difference": 0.0, + "latency_ms": 117.80334264039993 + }, + { + "name": "26-options", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 0.07546718418598175, + 0.00034948240499943495, + 0.263406366109848, + 0.557631254196167, + 0.009013270027935505, + 0.01908109337091446, + 0.007019542157649994, + 0.016839005053043365, + 0.009013270027935505, + 0.0025823453906923532, + 0.004824455827474594, + 0.003315796609967947, + 0.002011132426559925, + 0.0022789116483181715, + 0.00619472423568368, + 0.0010764816543087363, + 0.0037572900764644146, + 0.0006529190577566624, + 0.002011132426559925, + 0.0012198134791105986, + 0.00044874430750496686, + 0.0005084939184598625, + 0.003315796609967947, + 0.0013822298496961594, + 0.0017748181708157063, + 0.004824455827474594 + ], + "max_abs_difference": 0.0, + "latency_ms": 141.8488211929798 + }, + { + "name": "structured", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 0.07443060725927353, + 0.9067503809928894, + 0.01881900243461132 + ], + "max_abs_difference": 0.0, + "latency_ms": 121.30219116806984 + }, + { + "name": "special-token", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 0.531209409236908, + 0.4687906503677368 + ], + "max_abs_difference": 0.0, + "latency_ms": 117.51110758632421 + }, + { + "name": "two-questions", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + "probabilities": [ + 0.9958575367927551, + 0.0005507932510226965, + 0.003591623157262802 + ], + "max_abs_difference": 0.0, + "latency_ms": 103.49029209464788 + }, + { + "name": "two-questions", + "question": "second", + "inputs": { + "input_ids": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "1bc665c3f5aa0134e368d1a9edf0e652ec604cf43e969d59b14f696a4cf5c9c3" + }, + "attention_mask": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "bbdd8ad88f622ea9585a6b471f3ef6810a0c3374e43dbcb747e3077de4e6e674" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "6dc930bb14d93a028e6d2db398b391c4fe5af99184ec6625d38d2f7820e182f3" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + "probabilities": [ + 0.22270014882087708, + 0.7772998809814453 + ], + "max_abs_difference": 0.0, + "latency_ms": 104.30925991386175 + } + ], + "reference_source": { + "path": "libs/cua-s1/python/src/cua_s1/four_b.py", + "sha256": "7ed1adfd92223bef7d533db7efbb4cbf468c4936c4380ae42aee12097e3b9ea7", + "revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f" + }, + "load_ms": 19939.03631903231, + "warmup_ms": 1815.6465897336602, + "adapter_modules": 178, + "peak_allocated_bytes": 9657058304 +} \ No newline at end of file diff --git a/recipe/cua_s1/experiments/rtx4090/frontend.json b/recipe/cua_s1/experiments/rtx4090/frontend.json new file mode 100644 index 0000000..39cee2e --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090/frontend.json @@ -0,0 +1,79 @@ +[ + { + "name": "health", + "status": 200, + "content_type": "application/json", + "body_sha256": "f54feed005f2b4d1d6f2398a306d13aeaaa0c90aea20b5cca2a4de4ecab5bdd7", + "identical": true + }, + { + "name": "26-options", + "status": 200, + "content_type": "application/json", + "body_sha256": "64889fe4b0e85dac1c361d29a4367ed27fe63ceb75d94166ee867ba11ceb83d3", + "identical": true + }, + { + "name": "jpeg", + "status": 200, + "content_type": "application/json", + "body_sha256": "aeedac2faea6c8d9cc6e8636751833f5ee03b88dc8092f8a9d93e4320eb3f887", + "identical": true + }, + { + "name": "medium", + "status": 200, + "content_type": "application/json", + "body_sha256": "1d6041c8144e070b2d766cc1c85c52764addcb4745da88e96f94c5058678e62c", + "identical": true + }, + { + "name": "single", + "status": 200, + "content_type": "application/json", + "body_sha256": "6e9194fc25bc7ec8741dabd52ee4dfb3412b5c18eac22c2935b3ba96989c7a8c", + "identical": true + }, + { + "name": "small", + "status": 200, + "content_type": "application/json", + "body_sha256": "51fa5f1cf910140c958cc2c6ca3738699527dd47cee58809060ac6017400602e", + "identical": true + }, + { + "name": "special-token", + "status": 200, + "content_type": "application/json", + "body_sha256": "38646659005cdc82b81a5bac4ab8120f7f1e1b16bdb1c610fa72e5794ed5a439", + "identical": true + }, + { + "name": "structured", + "status": 200, + "content_type": "application/json", + "body_sha256": "21fe1ab16324d937eb8f9c6c692ccb1d1ad41d9d01cb078440dee0fde8990920", + "identical": true + }, + { + "name": "two-questions", + "status": 200, + "content_type": "application/json", + "body_sha256": "3f8dd307c92bf5dbf7e1ff1c928d3961265516e587ce162f905ded363f6764c1", + "identical": true + }, + { + "name": "invalid", + "status": 422, + "content_type": "application/json", + "body_sha256": "866753c516b9090204f79318fa8d289f42ef1650821ef4b974bc915ec2836832", + "identical": true + }, + { + "name": "duplicate", + "status": 422, + "content_type": "application/json", + "body_sha256": "1175f6c373a386204fa01db801fac92f0b772d5f2ef09a43e788ac72ae156a27", + "identical": true + } +] \ No newline at end of file diff --git a/recipe/cua_s1/experiments/rtx4090/packages.txt b/recipe/cua_s1/experiments/rtx4090/packages.txt new file mode 100644 index 0000000..646c8bb --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090/packages.txt @@ -0,0 +1,62 @@ +accelerate==1.15.0 +annotated-doc==0.0.5 +anyio==4.15.1 +certifi==2026.7.22 +click==8.5.0 +cuda-bindings==13.4.2 +cuda-pathfinder==1.8.2 +cuda-toolkit==13.0.3.0 +filelock==4.0.1 +fsspec==2026.9.0 +h11==0.16.0 +hf-xet==1.6.0 +httpcore==1.0.9 +httpx==0.28.1 +huggingface-hub==1.32.0 +idna==3.20 +iniconfig==2.3.0 +jinja2==3.1.6 +markdown-it-py==4.2.0 +markupsafe==3.0.3 +mdurl==0.1.2 +mpmath==1.3.0 +networkx==3.6.1 +numpy==2.5.3 +nvidia-cublas==13.1.1.3 +nvidia-cuda-cupti==13.0.85 +nvidia-cuda-nvrtc==13.0.88 +nvidia-cuda-runtime==13.0.96 +nvidia-cudnn-cu13==9.24.0.43 +nvidia-cufft==12.0.0.61 +nvidia-cufile==1.15.1.6 +nvidia-curand==10.4.0.35 +nvidia-cusolver==12.0.4.66 +nvidia-cusparse==12.6.3.3 +nvidia-cusparselt-cu13==0.8.1 +nvidia-nccl-cu13==2.30.7 +nvidia-nvjitlink==13.4.92 +nvidia-nvshmem-cu13==3.4.5 +nvidia-nvtx==13.0.85 +packaging==26.3 +peft==0.21.0 +pillow==11.3.0 +pluggy==1.6.0 +psutil==7.2.2 +pygments==2.21.0 +pytest==9.1.1 +pyyaml==6.0.3 +regex==2026.9.10 +rich==15.0.0 +ruff==0.16.8 +safetensors==0.8.0 +setuptools==84.0.0 +shellingham==1.5.4 +sympy==1.14.0 +tokenizers==0.23.2 +torch==2.14.0 +torchvision==0.29.0 +tqdm==4.70.1 +transformers==5.17.0 +triton==3.8.0 +typer==0.27.2 +typing-extensions==4.16.0 diff --git a/recipe/cua_s1/experiments/rtx4090/reference.json b/recipe/cua_s1/experiments/rtx4090/reference.json new file mode 100644 index 0000000..eaba46f --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090/reference.json @@ -0,0 +1,527 @@ +{ + "environment": { + "python": "3.12.13", + "gpu": "NVIDIA GeForce RTX 4090", + "compute_capability": [ + 8, + 9 + ], + "cuda": "13.0", + "driver": "595.71.05", + "torch_num_threads": 64, + "torch_num_interop_threads": 64, + "packages": { + "torch": "2.14.0", + "torchvision": "0.29.0", + "transformers": "5.17.0", + "peft": "0.21.0", + "pillow": "11.3.0", + "safetensors": "0.8.0", + "triton": "3.8.0" + }, + "reference_revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f", + "base_revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", + "adapter_revision": "16818868b0cc7813808aae4e87b417657046ab79", + "dtype": "bfloat16", + "adapter_merged": false + }, + "mode": "reference", + "cases": [ + { + "name": "small", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + "probabilities": [ + 0.9958575367927551, + 0.0005507932510226965, + 0.003591623157262802 + ], + "latency_ms": 147.01103698462248 + }, + { + "name": "medium", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 0.9958575367927551, + 0.0005507932510226965, + 0.003591623157262802 + ], + "latency_ms": 149.6963743120432 + }, + { + "name": "jpeg", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 0.9936226010322571, + 0.0011634123511612415, + 0.005214052740484476 + ], + "latency_ms": 137.3040061444044 + }, + { + "name": "single", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "c4d7b1102e94984504efa938052a0bba3639ba85f9917de3e8af5426ceefd16b" + }, + "attention_mask": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "3419eb840bd7f9d9e4b1fa6aaea783bae7a4752068701794687337702c2d8968" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "077d91126e88fd3e8ba97a2d8079c28a4d5da388e56c89ca0e584fd5ad4b3641" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 1.0 + ], + "latency_ms": 135.01203525811434 + }, + { + "name": "26-options", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 0.07546718418598175, + 0.00034948240499943495, + 0.263406366109848, + 0.557631254196167, + 0.009013270027935505, + 0.01908109337091446, + 0.007019542157649994, + 0.016839005053043365, + 0.009013270027935505, + 0.0025823453906923532, + 0.004824455827474594, + 0.003315796609967947, + 0.002011132426559925, + 0.0022789116483181715, + 0.00619472423568368, + 0.0010764816543087363, + 0.0037572900764644146, + 0.0006529190577566624, + 0.002011132426559925, + 0.0012198134791105986, + 0.00044874430750496686, + 0.0005084939184598625, + 0.003315796609967947, + 0.0013822298496961594, + 0.0017748181708157063, + 0.004824455827474594 + ], + "latency_ms": 314.77690767496824 + }, + { + "name": "structured", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 0.07443060725927353, + 0.9067503809928894, + 0.01881900243461132 + ], + "latency_ms": 141.84184558689594 + }, + { + "name": "special-token", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 0.531209409236908, + 0.4687906503677368 + ], + "latency_ms": 140.13662841171026 + }, + { + "name": "two-questions", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + "probabilities": [ + 0.9958575367927551, + 0.0005507932510226965, + 0.003591623157262802 + ], + "latency_ms": 114.18061796575785 + }, + { + "name": "two-questions", + "question": "second", + "inputs": { + "input_ids": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "1bc665c3f5aa0134e368d1a9edf0e652ec604cf43e969d59b14f696a4cf5c9c3" + }, + "attention_mask": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "bbdd8ad88f622ea9585a6b471f3ef6810a0c3374e43dbcb747e3077de4e6e674" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "6dc930bb14d93a028e6d2db398b391c4fe5af99184ec6625d38d2f7820e182f3" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + "probabilities": [ + 0.22270014882087708, + 0.7772998809814453 + ], + "latency_ms": 117.08385031670332 + } + ], + "reference_source": { + "path": "libs/cua-s1/python/src/cua_s1/four_b.py", + "sha256": "7ed1adfd92223bef7d533db7efbb4cbf468c4936c4380ae42aee12097e3b9ea7", + "revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f" + }, + "artifact_verification_ms": 9541.830752044916, + "load_ms": 16820.161445997655, + "warmup_ms": 3665.197447873652, + "peak_allocated_bytes": 9655206912 +} \ No newline at end of file diff --git a/recipe/cua_s1/make_example.py b/recipe/cua_s1/make_example.py new file mode 100644 index 0000000..8adbc53 --- /dev/null +++ b/recipe/cua_s1/make_example.py @@ -0,0 +1,71 @@ +"""Create redistributable synthetic GUI fixtures and inline-image requests.""" + +from __future__ import annotations + +import argparse +import base64 +import json +from pathlib import Path + +from PIL import Image, ImageDraw + + +def make_example(path: Path, size=(640, 480), fmt="PNG") -> dict: + image = Image.new("RGB", size, "#f4f6f8") + draw = ImageDraw.Draw(image) + w, h = size + draw.rectangle( + (w // 10, h // 8, w * 9 // 10, h * 7 // 8), + fill="white", + outline="#8899aa", + width=2, + ) + draw.text( + (w // 7, h // 5), "Account settings", fill="black", font_size=max(12, w // 25) + ) + draw.text( + (w // 7, h // 3), + "Display name: Alice", + fill="black", + font_size=max(10, w // 32), + ) + draw.rectangle((w // 7, h // 2, w * 4 // 7, h * 2 // 3), fill="#1460b4") + draw.text( + (w // 6, h * 13 // 24), "Save changes", fill="white", font_size=max(10, w // 32) + ) + draw.text( + (w * 5 // 8, h * 13 // 24), "Cancel", fill="black", font_size=max(10, w // 32) + ) + image.save(path, format=fmt) + mime = "jpeg" if fmt == "JPEG" else "png" + return { + "model": "cua-s1-4b-0.2", + "state": { + "image": f"data:image/{mime};base64," + + base64.b64encode(path.read_bytes()).decode() + }, + "questions": { + "next": { + "type": "choice", + "instructions": "Save the changed display name.", + "criteria": { + "save": "Click Save changes", + "cancel": "Click Cancel", + "wait": "Wait", + }, + } + }, + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path, default=Path("example.json")) + args = parser.parse_args() + args.output.parent.mkdir(parents=True, exist_ok=True) + value = make_example(args.output.with_suffix(".png")) + args.output.write_text(json.dumps(value, ensure_ascii=False)) + + +if __name__ == "__main__": + main() diff --git a/recipe/cua_s1/requirements-multimodal.txt b/recipe/cua_s1/requirements-multimodal.txt new file mode 100644 index 0000000..afb7422 --- /dev/null +++ b/recipe/cua_s1/requirements-multimodal.txt @@ -0,0 +1,11 @@ +# Reference package versions from trycua/cua 0e75660, four-b uv.lock. +# Lock the CUDA wheel/driver in the experiment report for the target GPU. +torch==2.14.0 +torchvision==0.29.0 +transformers==5.17.0 +peft==0.21.0 +accelerate==1.15.0 +Pillow==11.3.0 +safetensors==0.8.0 +huggingface-hub==1.32.0 +tokenizers==0.23.2 diff --git a/src/models/cua_s1/multimodal/THIRD_PARTY_NOTICES.md b/src/models/cua_s1/multimodal/THIRD_PARTY_NOTICES.md new file mode 100644 index 0000000..b8b198c --- /dev/null +++ b/src/models/cua_s1/multimodal/THIRD_PARTY_NOTICES.md @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025 Cua AI, Inc. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/src/models/cua_s1/multimodal/model.py b/src/models/cua_s1/multimodal/model.py new file mode 100644 index 0000000..db55070 --- /dev/null +++ b/src/models/cua_s1/multimodal/model.py @@ -0,0 +1,164 @@ +"""Direct Transformers/PEFT execution. No production dependency on cua_s1.""" + +from __future__ import annotations + +import hashlib +import json +from pathlib import Path + +from .protocol import InvalidRequest, Question, Request, answer, build_messages + +REFERENCE_REVISION = "0e75660ce4c2edda519e0c795fa3ad98abf4e76f" +BASE_REVISION = "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a" +ADAPTER_REVISION = "16818868b0cc7813808aae4e87b417657046ab79" +IDENTITY = f"cua-ai/cua-s1-4b-0.2@{ADAPTER_REVISION}:multimodal" +MAX_TOKENS = 4096 + + +def letter_ids(tokenizer, count: int) -> list[int]: + ids = [] + for index in range(count): + encoded = tokenizer.encode(chr(65 + index), add_special_tokens=False) + if len(encoded) != 1: + raise ValueError("each candidate letter must be a single token") + ids.append(encoded[0]) + return ids + + +def validate_adapter_config(config: dict): + targets = { + "q_proj", + "k_proj", + "v_proj", + "o_proj", + "gate_proj", + "up_proj", + "down_proj", + "linear_fc1", + "linear_fc2", + } + if ( + config.get("peft_type") != "LORA" + or config.get("r") != 16 + or config.get("lora_alpha") != 32 + or set(config.get("target_modules", [])) != targets + or config.get("base_model_name_or_path") != "Qwen/Qwen3.5-4B" + ): + raise ValueError("expected the pinned 0.2 multimodal LoRA adapter") + + +def verify_weights(base: Path, adapter: Path): + """Check local artifacts before assigning the pinned identity to responses.""" + lock = json.loads(Path(__file__).with_name("weights.lock.json").read_text()) + allowed = {base: set(), adapter: set()} + for artifact in lock["artifacts"]: + for name, expected in artifact["files"].items(): + if artifact["role"] == "adapter": + if not name.startswith("multimodal/"): + continue + path = adapter / name.removeprefix("multimodal/") + else: + path = base / name + root = adapter if artifact["role"] == "adapter" else base + allowed[root].add(path.relative_to(root).as_posix()) + if not path.is_file() or path.stat().st_size != expected["size"]: + raise ValueError(f"missing or wrong-size pinned artifact: {path.name}") + with path.open("rb") as handle: + digest = hashlib.file_digest(handle, "sha256").hexdigest() + if digest != expected["sha256"]: + raise ValueError(f"checksum mismatch: {path.name}") + for root, names in allowed.items(): + for path in root.rglob("*"): + relative = path.relative_to(root) + if path.is_file() and relative.parts[0] != ".cache": + if relative.as_posix() not in names: + raise ValueError( + f"unlisted artifact may override pinned files: {relative}" + ) + + +class MultimodalEngine: + def __init__( + self, base: str, adapter: str, device: str = "cuda", dtype: str = "bfloat16" + ): + import torch + from peft import PeftModel + from peft.tuners.lora import LoraLayer + from transformers import ( + AutoModelForImageTextToText, + AutoProcessor, + AutoTokenizer, + ) + + base_path, adapter_path = Path(base), Path(adapter) + verify_weights(base_path, adapter_path) + validate_adapter_config( + json.loads((adapter_path / "adapter_config.json").read_text()) + ) + self.tokenizer = AutoTokenizer.from_pretrained(base, local_files_only=True) + self.processor = AutoProcessor.from_pretrained(base, local_files_only=True) + model = AutoModelForImageTextToText.from_pretrained( + base, + torch_dtype=getattr(torch, dtype), + device_map=device, + local_files_only=True, + ) + self.model = PeftModel.from_pretrained(model, adapter, local_files_only=True) + modules = [ + name + for name, module in self.model.named_modules() + if isinstance(module, LoraLayer) + ] + if len(modules) != 178 or not any(".visual." in name for name in modules): + raise RuntimeError( + "multimodal adapter did not attach to all 178 expected modules" + ) + self.adapter_modules = len(modules) + self.model.eval() + self.dtype = dtype + + def prepare(self, image, question: Question): + messages = build_messages(question) + text = self.processor.apply_chat_template( + messages, tokenize=False, add_generation_prompt=True + ) + inputs = self.processor(text=[text], images=[image], return_tensors="pt") + if inputs["input_ids"].shape[-1] > MAX_TOKENS: + raise InvalidRequest(f"processed prompt exceeds {MAX_TOKENS} tokens") + return inputs + + def score(self, inputs, question: Question) -> list[float]: + import torch + + ids = letter_ids(self.tokenizer, len(question.keys)) + inputs = inputs.to(self.model.device) + with torch.no_grad(): + output = self.model(**inputs) + logits = output.logits[0, -1, :] + return torch.softmax( + logits[torch.tensor(ids, device=logits.device)].float(), dim=-1 + ).tolist() + + def predict(self, request: Request) -> dict: + # Validate all processed lengths before executing any question. + prepared = [self.prepare(request.image, q) for q in request.questions] + answers = { + q.name: answer(q, self.score(inputs, q)) + for q, inputs in zip(request.questions, prepared) + } + return { + "model": IDENTITY, + "answers": answers, + "usage": { + "input_tokens": sum(x["input_ids"].shape[-1] for x in prepared), + "output_tokens": 0, + }, + } + + def warmup(self): + from PIL import Image + + q = Question( + "warmup", ("continue", "cancel"), ("Continue", "Cancel"), "Continue" + ) + self.predict(Request(Image.new("RGB", (224, 224), "white"), (q,))) diff --git a/src/models/cua_s1/multimodal/protocol.py b/src/models/cua_s1/multimodal/protocol.py new file mode 100644 index 0000000..0a0157a --- /dev/null +++ b/src/models/cua_s1/multimodal/protocol.py @@ -0,0 +1,217 @@ +"""Bounded screenshot-only extension of the Cua-S1 choice contract in PR #11.""" + +from __future__ import annotations + +import base64 +import binascii +import io +import json +import math +from dataclasses import dataclass + +from PIL import Image, UnidentifiedImageError + +MODEL = "cua-s1-4b-0.2" +MAX_BODY = 8 * 1024 * 1024 +MAX_IMAGE_BYTES = 4 * 1024 * 1024 +MAX_PIXELS = 1024 * 1024 +MAX_SIDE = 2048 +MAX_QUESTIONS = 8 +MAX_TEXT = 16384 + +# Prompt and letter layout follow trycua/cua at 0e75660ce4c2edda519e0c795fa3ad98abf4e76f. +# See THIRD_PARTY_NOTICES.md for the upstream MIT notice. +SYSTEM_PROMPT = ( + "You are a one-pass computer-use decision model. You are shown the " + "current state of a screen and a fixed, closed list of candidate " + "(element, action) options, each given a single letter. Choose exactly " + "one option: the single best next action to take. Answer with ONLY that " + "option's letter -- no words, no punctuation, no explanation." +) + + +class InvalidRequest(ValueError): + """Input cannot be evaluated under the supported contract.""" + + +@dataclass(frozen=True) +class Question: + name: str + keys: tuple[str, ...] + labels: tuple[str, ...] + goal: str + + +@dataclass(frozen=True) +class Request: + image: Image.Image + questions: tuple[Question, ...] + + +def _object(pairs): + result = {} + for key, value in pairs: + if key in result: + raise InvalidRequest("duplicate JSON keys are not supported") + result[key] = value + return result + + +def _nonfinite(value): + raise InvalidRequest("non-finite JSON numbers are not supported") + + +def decode_request(raw: bytes) -> dict: + if len(raw) > MAX_BODY: + raise InvalidRequest("request body exceeds 8 MiB") + try: + value = json.loads(raw, object_pairs_hook=_object, parse_constant=_nonfinite) + except (ValueError, UnicodeError, RecursionError) as exc: + raise InvalidRequest("invalid JSON or duplicate keys") from exc + if not isinstance(value, dict): + raise InvalidRequest("request must be a JSON object") + return value + + +def _text(value, field): + if not isinstance(value, (str, dict, list)): + raise InvalidRequest(f"{field} must be a string, object or array") + try: + result = ( + value + if isinstance(value, str) + else json.dumps(value, ensure_ascii=False, allow_nan=False) + ) + except (ValueError, TypeError, RecursionError) as exc: + raise InvalidRequest(f"invalid {field}") from exc + if len(result) > MAX_TEXT: + raise InvalidRequest(f"{field} exceeds {MAX_TEXT} characters") + if any( + token in result + for token in ( + "<|image_pad|>", + "<|video_pad|>", + "<|vision_start|>", + "<|vision_end|>", + ) + ): + raise InvalidRequest(f"{field} contains an unsupported media control token") + return result + + +def _image(state): + if not isinstance(state, dict) or set(state) != {"image"}: + raise InvalidRequest("state must contain exactly one image data URL") + url = state["image"] + if not isinstance(url, str): + raise InvalidRequest("state.image must be a PNG/JPEG base64 data URL") + prefix, separator, encoded = url.partition(",") + expected = {"data:image/png;base64": "PNG", "data:image/jpeg;base64": "JPEG"} + if not separator or prefix not in expected: + raise InvalidRequest("only inline PNG/JPEG images are supported") + if len(encoded) > 4 * ((MAX_IMAGE_BYTES + 2) // 3): + raise InvalidRequest("encoded image exceeds 4 MiB") + try: + raw = base64.b64decode(encoded, validate=True) + if len(raw) > MAX_IMAGE_BYTES: + raise InvalidRequest("image exceeds 4 MiB") + with Image.open(io.BytesIO(raw)) as source: + if source.format != expected[prefix]: + raise InvalidRequest("image format does not match its MIME type") + w, h = source.size + if ( + max(w, h) > MAX_SIDE + or w * h > MAX_PIXELS + or getattr(source, "n_frames", 1) != 1 + ): + raise InvalidRequest( + "image must be single-frame, at most 2048 per side and 1048576 pixels" + ) + source.load() + return source.convert("RGB") + except ( + binascii.Error, + UnidentifiedImageError, + OSError, + Image.DecompressionBombError, + ValueError, + ) as exc: + if isinstance(exc, InvalidRequest): + raise + raise InvalidRequest("invalid image data") from exc + + +def parse_request(value: dict) -> Request: + if not isinstance(value, dict) or set(value) != {"model", "state", "questions"}: + raise InvalidRequest("request must contain model, state and questions only") + if value["model"] != MODEL: + raise InvalidRequest(f"model must be {MODEL}") + questions = value["questions"] + if not isinstance(questions, dict) or not 1 <= len(questions) <= MAX_QUESTIONS: + raise InvalidRequest("questions must contain 1 to 8 questions") + parsed = [] + for name, q in questions.items(): + if not isinstance(name, str) or not name or len(name) > 256: + raise InvalidRequest("question names must contain 1 to 256 characters") + if not isinstance(q, dict) or q.get("type") != "choice": + raise InvalidRequest("only choice questions are supported") + if set(q) - {"type", "instructions", "criteria"}: + raise InvalidRequest("unsupported question fields") + criteria = q.get("criteria") + if not isinstance(criteria, dict) or not 1 <= len(criteria) <= 26: + raise InvalidRequest("choice requires 1 to 26 options") + labels = [] + for key, label in criteria.items(): + if not isinstance(key, str) or not key or len(key) > 256: + raise InvalidRequest("option keys must contain 1 to 256 characters") + text = _text(key if label is None else label, "criteria") + labels.append(json.dumps(text, ensure_ascii=False)[1:-1]) + goal = _text(q.get("instructions", ""), "instructions") + if len(goal) + sum(map(len, labels)) > MAX_TEXT: + raise InvalidRequest("combined question text exceeds 16384 characters") + parsed.append(Question(name, tuple(criteria), tuple(labels), goal)) + return Request(_image(value["state"]), tuple(parsed)) + + +def build_messages(q: Question, image_marker: str = "inline.png") -> list[dict]: + lines = "\n".join( + f'{chr(65 + i)}. Decision "{label}" -> select' + for i, label in enumerate(q.labels) + ) + text = ( + (f"Goal: {q.goal}\n\n" if q.goal else "") + + "App: Cua Driver\nTask family: closed-candidate decision\n\n" + + "The current screenshot is attached.\n\n" + + f"Options:\n{lines}\n\nAnswer with a single letter." + ) + return [ + {"role": "system", "content": SYSTEM_PROMPT}, + { + "role": "user", + "content": [ + {"type": "image", "image": image_marker}, + {"type": "text", "text": text}, + ], + }, + ] + + +def answer(q: Question, probabilities: list[float]) -> dict: + if len(probabilities) != len(q.keys) or any( + not math.isfinite(p) or not 0 <= p <= 1 for p in probabilities + ): + raise ValueError("model returned invalid probabilities") + if not math.isclose(sum(probabilities), 1.0, abs_tol=1e-5): + raise ValueError("model probabilities do not sum to one") + n = len(probabilities) + confidence = ( + 1.0 + if n == 1 + else 1 + sum(p * math.log(p) for p in probabilities if p) / math.log(n) + ) + return { + "type": "choice", + "choice": q.keys[max(range(n), key=probabilities.__getitem__)], + "probabilities": dict(zip(q.keys, probabilities)), + "confidence": max(0.0, min(1.0, confidence)), + } diff --git a/src/models/cua_s1/multimodal/server.py b/src/models/cua_s1/multimodal/server.py new file mode 100644 index 0000000..a399dac --- /dev/null +++ b/src/models/cua_s1/multimodal/server.py @@ -0,0 +1,128 @@ +"""Small loopback HTTP worker; the Rust frontend remains the public serving layer.""" + +from __future__ import annotations + +import argparse +import json +import logging +import socket +import threading +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer + +from .protocol import MAX_BODY, InvalidRequest, decode_request, parse_request + +LOG = logging.getLogger(__name__) + + +class WorkerServer(ThreadingHTTPServer): + daemon_threads = True + + def __init__(self, address, engine): + self.engine = engine + self.inference_lock = threading.Lock() + super().__init__(address, Handler) + + +class Handler(BaseHTTPRequestHandler): + def setup(self): + super().setup() + self.connection.settimeout(15) + + def log_message(self, format, *args): + # Do not log paths, input images, instructions or arbitrary request headers. + pass + + def send_json(self, status, value): + raw = json.dumps(value, ensure_ascii=False, allow_nan=False).encode("utf-8") + self.send_response(status) + self.send_header("Content-Type", "application/json") + self.send_header("Content-Length", str(len(raw))) + self.end_headers() + try: + self.wfile.write(raw) + except (BrokenPipeError, ConnectionResetError): + pass + + def do_GET(self): + if self.path == "/health": + self.send_json(200, {"status": "ready", "modality": "multimodal"}) + else: + self.send_json(404, {"error": "unknown route"}) + + def do_POST(self): + if self.path != "/v1/systemone": + self.send_json(404, {"error": "unknown route"}) + return + if self.headers.get("Transfer-Encoding"): + self.send_json( + 411, + { + "error": "Content-Length is required; chunked requests are unsupported" + }, + ) + return + lengths = self.headers.get_all("Content-Length", []) + if len(lengths) != 1: + self.send_json(411, {"error": "one Content-Length is required"}) + return + try: + length = int(lengths[0]) + except ValueError: + self.send_json(400, {"error": "invalid Content-Length"}) + return + if length < 0 or length > MAX_BODY: + self.send_json(413, {"error": "request exceeds body limit"}) + return + if self.headers.get_content_type() != "application/json": + self.send_json(415, {"error": "Content-Type must be application/json"}) + return + if not self.server.inference_lock.acquire(blocking=False): + self.send_json(503, {"error": "worker busy"}) + return + try: + raw = self.rfile.read(length) + if len(raw) != length: + self.send_json(400, {"error": "incomplete body"}) + return + parsed = parse_request(decode_request(raw)) + result = self.server.engine.predict(parsed) + self.send_json(200, result) + except InvalidRequest as exc: + self.send_json(422, {"error": str(exc)}) + except (TimeoutError, socket.timeout): + self.send_json(408, {"error": "request body timed out"}) + except Exception as exc: + LOG.error("inference failed: %s", type(exc).__name__) + self.send_json(500, {"error": "inference failed"}) + finally: + self.server.inference_lock.release() + + +def main(): + from .model import MultimodalEngine + + p = argparse.ArgumentParser(description=__doc__) + p.add_argument( + "--base", required=True, help="verified local base checkpoint directory" + ) + p.add_argument( + "--adapter", required=True, help="verified local multimodal adapter directory" + ) + p.add_argument("--port", type=int, default=8000) + args = p.parse_args() + logging.basicConfig(level=logging.INFO) + engine = MultimodalEngine(args.base, args.adapter) + engine.warmup() + # Bind only after model loading and a representative inference succeed. + server = WorkerServer(("127.0.0.1", args.port), engine) + LOG.info("multimodal worker ready on 127.0.0.1:%s", args.port) + try: + server.serve_forever() + except KeyboardInterrupt: + pass + finally: + server.server_close() + + +if __name__ == "__main__": + main() diff --git a/src/models/cua_s1/multimodal/weights.lock.json b/src/models/cua_s1/multimodal/weights.lock.json new file mode 100644 index 0000000..dfb9748 --- /dev/null +++ b/src/models/cua_s1/multimodal/weights.lock.json @@ -0,0 +1,102 @@ +{ + "schema": "cua-s1/weights-lock/v1", + "description": "Pinned public Hugging Face artifacts for the weights-backed Cua-S1-4B smoke. Every listed file is downloaded at the pinned revision and verified by size and SHA-256; keep in sync with libs/cua-s1/README.md.", + "artifacts": [ + { + "name": "Qwen3.5-4B", + "repo_id": "Qwen/Qwen3.5-4B", + "revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", + "role": "base", + "files": { + ".gitattributes": { + "size": 1570, + "sha256": "34448b82c17d60fec9b65b1f093c115ddbaadc04beb1b0140b6bfed2e012a930" + }, + "LICENSE": { + "size": 11544, + "sha256": "bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a" + }, + "README.md": { + "size": 77661, + "sha256": "1406be1b6b8fd8a6545870da516912804756593628a1d0fb0a7965211e82a7bb" + }, + "chat_template.jinja": { + "size": 7756, + "sha256": "a4aee8afcf2e0711942cf848899be66016f8d14a889ff9ede07bca099c28f715" + }, + "config.json": { + "size": 3161, + "sha256": "ddc63e1c717afa86c865bb5e01313d89d72bb53b97ad4a8a03ba8510c0621670" + }, + "merges.txt": { + "size": 3353259, + "sha256": "a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d" + }, + "model.safetensors-00001-of-00002.safetensors": { + "size": 5329398688, + "sha256": "26a93f066e1916adb13453dae5a0c707c0fbc71299ed98779571a907b8e74c61" + }, + "model.safetensors-00002-of-00002.safetensors": { + "size": 3990429408, + "sha256": "cb544bd9bfae93dc59b0f22b292f5933573854a7f9b97835c67060d7d910e188" + }, + "model.safetensors.index.json": { + "size": 76196, + "sha256": "cf3f798ee02ba45f9622aa8892a47369ab667d0afbf154ee7c2212de42e6302d" + }, + "preprocessor_config.json": { + "size": 390, + "sha256": "27225450ac9c6529872ee1924fcb0962ff5634834f817040f444118116f4e516" + }, + "tokenizer.json": { + "size": 12807982, + "sha256": "5f9e4d4901a92b997e463c1f46055088b6cca5ca61a6522d1b9f64c4bb81cb42" + }, + "tokenizer_config.json": { + "size": 16710, + "sha256": "316230d6a809701f4db5ea8f8fc862bc3a6f3229c937c174e674ff3ca0a64ac8" + }, + "video_preprocessor_config.json": { + "size": 385, + "sha256": "7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13" + }, + "vocab.json": { + "size": 6722759, + "sha256": "ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003" + } + } + }, + { + "name": "cua-s1-4b-0.2", + "repo_id": "cua-ai/cua-s1-4b-0.2", + "revision": "16818868b0cc7813808aae4e87b417657046ab79", + "role": "adapter", + "files": { + ".gitattributes": { + "size": 1519, + "sha256": "11ad7efa24975ee4b0c3c3a38ed18737f0658a5f75a0a96787b576a78a023361" + }, + "README.md": { + "size": 1134, + "sha256": "0e89cb4aea205e08c13f8af7fbfdfd0854ba0f6c57602071238771d0e1f8c7cd" + }, + "multimodal/adapter_config.json": { + "size": 1129, + "sha256": "f80edac43dd7605317ae8189613c75d13a029fa5d8a4870c04f1ba7097a8fab5" + }, + "multimodal/adapter_model.safetensors": { + "size": 101665112, + "sha256": "38ecd5a9191a436c1739db29104517f0aff4c70d0736d9cd810d3d49cfd652ea" + }, + "text/adapter_config.json": { + "size": 1091, + "sha256": "c246fce1fe1d44160ae5f246f9881dfeabb4fcd67fe4a777cef10a1dbcf16540" + }, + "text/adapter_model.safetensors": { + "size": 84968408, + "sha256": "9b59c5aed96171a50b26526613766bbf44347a5c7af70f81efe6bcc6e9dbfb0e" + } + } + } + ] +} diff --git a/tests/cua_s1/test_evaluation.py b/tests/cua_s1/test_evaluation.py new file mode 100644 index 0000000..b35ec7c --- /dev/null +++ b/tests/cua_s1/test_evaluation.py @@ -0,0 +1,48 @@ +"""Provenance checks must fail before a changed oracle can certify parity.""" + +import importlib.util +from pathlib import Path + +import pytest + + +def test_modified_reference_is_rejected(tmp_path, monkeypatch): + recipe = Path(__file__).resolve().parents[2] / "recipe/cua_s1" + monkeypatch.syspath_prepend(str(recipe)) + spec = importlib.util.spec_from_file_location( + "evaluation", recipe / "evaluate_multimodal.py" + ) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + source = tmp_path / module.REFERENCE_SOURCE + source.parent.mkdir(parents=True) + source.write_text("modified oracle") + with pytest.raises(ValueError, match="reference source differs"): + module.verify_reference(tmp_path) + + +def test_environment_survives_json_roundtrip(monkeypatch): + import json + import sys + from types import SimpleNamespace + + recipe = Path(__file__).resolve().parents[2] / "recipe/cua_s1" + monkeypatch.syspath_prepend(str(recipe)) + spec = importlib.util.spec_from_file_location( + "evaluation", recipe / "evaluate_multimodal.py" + ) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + torch = SimpleNamespace( + cuda=SimpleNamespace( + get_device_name=lambda: "GPU", get_device_capability=lambda: (8, 9) + ), + version=SimpleNamespace(cuda="13.0"), + get_num_threads=lambda: 16, + get_num_interop_threads=lambda: 16, + ) + monkeypatch.setitem(sys.modules, "torch", torch) + monkeypatch.setattr(module.importlib.metadata, "version", lambda name: "pinned") + monkeypatch.setattr(module.subprocess, "check_output", lambda *a, **kw: "driver\n") + environment = module.environment() + assert json.loads(json.dumps(environment)) == environment diff --git a/tests/cua_s1/test_model.py b/tests/cua_s1/test_model.py new file mode 100644 index 0000000..228e3ac --- /dev/null +++ b/tests/cua_s1/test_model.py @@ -0,0 +1,112 @@ +import pytest + +from models.cua_s1.multimodal.model import letter_ids, validate_adapter_config + + +class Tokenizer: + def encode(self, text, add_special_tokens): + assert add_special_tokens is False + return [ord(text) - 33] + + +def test_letter_readout_is_in_candidate_order(): + assert letter_ids(Tokenizer(), 3) == [32, 33, 34] + + +def test_multitoken_letters_are_rejected(): + class Bad: + def encode(self, *args, **kwargs): + return [1, 2] + + with pytest.raises(ValueError, match="single token"): + letter_ids(Bad(), 2) + + +def test_text_adapter_is_rejected_before_model_load(): + with pytest.raises(ValueError, match="multimodal"): + validate_adapter_config( + { + "peft_type": "LORA", + "r": 16, + "lora_alpha": 32, + "target_modules": ["q_proj", "k_proj"], + } + ) + + +def test_multimodal_adapter_contract(): + validate_adapter_config( + { + "peft_type": "LORA", + "r": 16, + "lora_alpha": 32, + "base_model_name_or_path": "Qwen/Qwen3.5-4B", + "target_modules": [ + "q_proj", + "k_proj", + "v_proj", + "o_proj", + "gate_proj", + "up_proj", + "down_proj", + "linear_fc1", + "linear_fc2", + ], + } + ) + + +def test_unlisted_model_files_cannot_override_verified_shards(tmp_path, monkeypatch): + import hashlib + import json + + from models.cua_s1.multimodal import model + + base, adapter = tmp_path / "base", tmp_path / "adapter" + base.mkdir() + adapter.mkdir() + (base / "config.json").write_bytes(b"{}") + manifest = tmp_path / "weights.lock.json" + manifest.write_text( + json.dumps( + { + "artifacts": [ + { + "role": "base", + "files": { + "config.json": { + "size": 2, + "sha256": hashlib.sha256(b"{}").hexdigest(), + } + }, + } + ] + } + ) + ) + monkeypatch.setattr(model, "__file__", str(tmp_path / "model.py")) + model.verify_weights(base, adapter) + (base / "model.safetensors").write_bytes(b"override") + with pytest.raises(ValueError, match="unlisted"): + model.verify_weights(base, adapter) + + +def test_all_question_lengths_are_checked_before_inference(): + from models.cua_s1.multimodal.model import MultimodalEngine + from models.cua_s1.multimodal.protocol import InvalidRequest, Question, Request + + engine = object.__new__(MultimodalEngine) + first = Question("first", ("a",), ("A",), "") + second = Question("second", ("b",), ("B",), "") + forwarded = [] + + def prepare(image, question): + if question.name == "second": + raise InvalidRequest("processed prompt exceeds 4096 tokens") + return {} + + engine.prepare = prepare + engine.score = lambda inputs, q: forwarded.append(q) + with pytest.raises(InvalidRequest, match="4096"): + engine.predict(Request(None, (first, second))) + assert forwarded == [] diff --git a/tests/cua_s1/test_protocol.py b/tests/cua_s1/test_protocol.py new file mode 100644 index 0000000..0165eae --- /dev/null +++ b/tests/cua_s1/test_protocol.py @@ -0,0 +1,156 @@ +import base64 +import io +import json + +import pytest +from PIL import Image + +from models.cua_s1.multimodal.protocol import ( + InvalidRequest, + answer, + build_messages, + decode_request, + parse_request, +) + + +def image_url(fmt="PNG", size=(32, 32)): + out = io.BytesIO() + Image.new("RGB", size, "white").save(out, format=fmt) + mime = "jpeg" if fmt == "JPEG" else "png" + return f"data:image/{mime};base64," + base64.b64encode(out.getvalue()).decode() + + +def request(): + return { + "model": "cua-s1-4b-0.2", + "state": {"image": image_url()}, + "questions": { + "next": { + "type": "choice", + "instructions": "Submit the form", + "criteria": {"submit": "Submit", "cancel": "Cancel"}, + } + }, + } + + +def test_image_and_order_are_preserved(): + r = parse_request(request()) + assert r.image.mode == "RGB" and r.image.size == (32, 32) + assert r.questions[0].keys == ("submit", "cancel") + assert r.questions[0].labels == ("Submit", "Cancel") + + +def test_prompt_keeps_image_block_and_upstream_text(): + q = parse_request(request()).questions[0] + msg = build_messages(q) + assert msg[1]["content"][0]["type"] == "image" + assert msg[1]["content"][1]["text"] == ( + "Goal: Submit the form\n\nApp: Cua Driver\nTask family: closed-candidate decision\n\n" + "The current screenshot is attached.\n\nOptions:\n" + 'A. Decision "Submit" -> select\nB. Decision "Cancel" -> select\n\n' + "Answer with a single letter." + ) + + +def test_structured_values_and_escaping(): + r = request() + r["questions"]["next"]["instructions"] = {"目标": "提交"} + r["questions"]["next"]["criteria"] = {"fallback": None, "obj": {"x": '"\n'}} + q = parse_request(r).questions[0] + assert q.goal == '{"目标": "提交"}' + assert q.labels == ( + "fallback", + json.dumps(json.dumps({"x": '"\n'}, ensure_ascii=False), ensure_ascii=False)[ + 1:-1 + ], + ) + + +@pytest.mark.parametrize( + "state", + [ + {}, + {"image": "/etc/passwd"}, + {"image": "https://example.com/a.png"}, + {"image": "data:image/png;base64,!!"}, + {"image": image_url(), "text": "ignored"}, + ], +) +def test_invalid_images_and_unknown_state_fields(state): + r = request() + r["state"] = state + with pytest.raises(InvalidRequest): + parse_request(r) + + +def test_mime_mismatch_and_oversized_dimensions(): + for url in [ + image_url().replace("image/png", "image/jpeg"), + image_url(size=(2049, 1)), + ]: + r = request() + r["state"]["image"] = url + with pytest.raises(InvalidRequest): + parse_request(r) + + +@pytest.mark.parametrize( + "criteria", [{}, {str(i): "x" for i in range(27)}, {"a": 1}, {"a": True}] +) +def test_invalid_candidates(criteria): + r = request() + r["questions"]["next"]["criteria"] = criteria + with pytest.raises(InvalidRequest): + parse_request(r) + + +@pytest.mark.parametrize("kind", ["score", "noul"]) +def test_unsupported_question_rejects_entire_request(kind): + r = request() + r["questions"]["bad"] = {"type": kind, "instructions": "x"} + with pytest.raises(InvalidRequest): + parse_request(r) + + +def test_duplicate_keys_and_nonfinite_json(): + for raw in [ + b'{"model":1,"model":2}', + b'{"x":NaN}', + b'{"x":Infinity}', + b"[]", + b"not json", + ]: + with pytest.raises(InvalidRequest): + decode_request(raw) + + +def test_entropy_confidence_and_earliest_tie(): + q = parse_request(request()).questions[0] + result = answer(q, [0.5, 0.5]) + assert result["choice"] == "submit" + assert result["confidence"] == 0.0 + assert result["probabilities"] == {"submit": 0.5, "cancel": 0.5} + r = request() + r["questions"]["next"]["criteria"] = {"only": "Only"} + assert answer(parse_request(r).questions[0], [1.0])["confidence"] == 1.0 + + +def test_jpeg_supported(): + r = request() + r["state"]["image"] = image_url("JPEG") + assert parse_request(r).image.mode == "RGB" + + +@pytest.mark.parametrize( + "token", ["<|image_pad|>", "<|video_pad|>", "<|vision_start|>", "<|vision_end|>"] +) +@pytest.mark.parametrize("field", ["instructions", "criteria"]) +def test_media_control_tokens_are_rejected(token, field): + value = request() + value["questions"]["next"][field] = ( + token if field == "instructions" else {"a": {"text": token}} + ) + with pytest.raises(InvalidRequest, match="control token"): + parse_request(value) diff --git a/tests/cua_s1/test_server.py b/tests/cua_s1/test_server.py new file mode 100644 index 0000000..89eddaa --- /dev/null +++ b/tests/cua_s1/test_server.py @@ -0,0 +1,85 @@ +import json +import threading +import urllib.error +import urllib.request + +import pytest +from test_protocol import request + +from models.cua_s1.multimodal.protocol import MAX_BODY +from models.cua_s1.multimodal.server import WorkerServer + + +class Engine: + def predict(self, parsed): + return { + "model": "test:multimodal", + "answers": {q.name: {"type": "choice"} for q in parsed.questions}, + } + + +@pytest.fixture +def worker(): + server = WorkerServer(("127.0.0.1", 0), Engine()) + thread = threading.Thread(target=server.serve_forever, daemon=True) + thread.start() + yield server, f"http://127.0.0.1:{server.server_port}" + server.shutdown() + server.server_close() + thread.join() + + +def call(url, body=None, **headers): + data = None if body is None else json.dumps(body).encode() + req = urllib.request.Request( + url, data=data, headers={"Content-Type": "application/json", **headers} + ) + try: + with urllib.request.urlopen(req, timeout=5) as response: + return response.status, json.load(response) + except urllib.error.HTTPError as response: + return response.code, json.load(response) + + +def test_health_and_prediction(worker): + _, url = worker + assert call(url + "/health")[0] == 200 + status, body = call(url + "/v1/systemone", request()) + assert status == 200 and "next" in body["answers"] + + +def test_invalid_question_never_reaches_model(worker): + _, url = worker + r = request() + r["questions"]["next"]["type"] = "noul" + assert call(url + "/v1/systemone", r)[0] == 422 + + +def test_busy_worker_rejects_instead_of_queueing_gpu_work(worker): + server, url = worker + server.inference_lock.acquire() + try: + assert call(url + "/health")[0] == 200 + assert call(url + "/v1/systemone", request())[0] == 503 + finally: + server.inference_lock.release() + + +def test_body_limit_checked_before_reading(worker): + _, url = worker + assert ( + call(url + "/v1/systemone", {}, **{"Content-Length": str(MAX_BODY + 1)})[0] + == 413 + ) + + +def test_model_failure_is_not_reported_as_success(worker): + server, url = worker + + def fail(_): + raise RuntimeError("private file or input must not leak") + + server.engine.predict = fail + status, body = call(url + "/v1/systemone", request()) + assert status == 500 and "private" not in json.dumps(body) + assert not server.inference_lock.locked() From 767e21172a303e36da4765fe59027db63f09acd1 Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 10:59:47 +0800 Subject: [PATCH 02/26] Add reproducible multimodal profiling matrix --- recipe/cua_s1/README.md | 4 + recipe/cua_s1/profile_multimodal.py | 425 ++++++++++++++++++++++++++++ recipe/cua_s1/profiling.md | 151 ++++++++++ tests/cua_s1/test_profiling.py | 392 +++++++++++++++++++++++++ 4 files changed, 972 insertions(+) create mode 100644 recipe/cua_s1/profile_multimodal.py create mode 100644 recipe/cua_s1/profiling.md create mode 100644 tests/cua_s1/test_profiling.py diff --git a/recipe/cua_s1/README.md b/recipe/cua_s1/README.md index cec424c..6dac894 100644 --- a/recipe/cua_s1/README.md +++ b/recipe/cua_s1/README.md @@ -107,6 +107,10 @@ branches, including 50 vision projection modules (178 total adapted modules). ## Reproduce correctness and profiling +For the staged image-size, text-length and same-image question-count experiment, +see [multimodal profiling](profiling.md), including hardware requirements and +separate unprofiled timing and instrumented traces. + ```sh git clone https://github.com/trycua/cua.git /tmp/cua-reference git -C /tmp/cua-reference checkout 0e75660ce4c2edda519e0c795fa3ad98abf4e76f diff --git a/recipe/cua_s1/profile_multimodal.py b/recipe/cua_s1/profile_multimodal.py new file mode 100644 index 0000000..3b66695 --- /dev/null +++ b/recipe/cua_s1/profile_multimodal.py @@ -0,0 +1,425 @@ +"""Profile a deterministic Cua-S1 workload matrix without instrumenting latency samples.""" + +from __future__ import annotations + +import argparse +import copy +import hashlib +import json +import statistics +import subprocess +import sys +import time +from contextlib import contextmanager +from pathlib import Path + +GOAL = "Save the changed display name." + + +def case_matrix(): + return [ + { + "id": f"{w}x{h}-{goal}-q{questions}", + "size": [w, h], + "goal": goal, + "goal_repetitions": 1 if goal == "short" else 64, + "questions": questions, + } + for w, h in [(320, 240), (640, 480)] + for goal in ["short", "long"] + for questions in [1, 2, 4, 8] + ] + + +def fixture(case, folder): + from make_example import make_example + + folder.mkdir(parents=True, exist_ok=True) + value = make_example(folder / f"{case['id']}.png", tuple(case["size"])) + question = value["questions"]["next"] + question["instructions"] = " ".join([GOAL] * case["goal_repetitions"]) + value["questions"] = { + f"q{i + 1}": copy.deepcopy(question) for i in range(case["questions"]) + } + write_json(folder / f"{case['id']}.json", value) + return value + + +def parse_args(argv=None): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--weights", type=Path) + parser.add_argument("--output", type=Path) + parser.add_argument("--list-cases", action="store_true") + parser.add_argument( + "--case", action="append", default=[], help="case id; repeatable" + ) + parser.add_argument( + "--profile", + action="append", + default=[], + help="case id for one traced request; repeatable", + ) + for name, default in [("warmup", 5), ("runs", 2), ("iterations", 50)]: + parser.add_argument(f"--{name}", type=int, default=default) + args = parser.parse_args(argv) + known = {case["id"] for case in case_matrix()} + for name in ("warmup", "runs", "iterations"): + if getattr(args, name) <= 0: + parser.error(f"--{name} must be positive") + for name in ("case", "profile"): + selected = getattr(args, name) + if len(selected) != len(set(selected)) or set(selected) - known: + parser.error(f"--{name} contains duplicate or unknown case ids") + if set(args.profile) - set(args.case or known): + parser.error("--profile cases must also be selected by --case") + if not args.list_cases and (args.weights is None or args.output is None): + parser.error("--weights and --output are required unless --list-cases is used") + return args + + +def write_json(path, value): + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text(json.dumps(value, indent=2, allow_nan=False) + "\n") + temporary.replace(path) + + +def repository_state(root): + def git(*args): + return subprocess.check_output( + ["git", "-C", str(root), *args], stderr=subprocess.PIPE + ) + + try: + revision = git("rev-parse", "HEAD").decode().strip() + status = git("status", "--porcelain=v1", "-z") + digest = hashlib.sha256(git("diff", "HEAD", "--binary")) + untracked = git("ls-files", "--others", "--exclude-standard", "-z") + for name in sorted(filter(None, untracked.split(b"\0"))): + path = root / name.decode() + content = path.read_bytes() + digest.update(name + b"\0" + hashlib.sha256(content).digest()) + return { + "revision": revision, + "dirty": bool(status), + "diff_sha256": digest.hexdigest(), + "untracked_files": [x.decode() for x in untracked.split(b"\0") if x], + } + except (subprocess.CalledProcessError, OSError) as exc: + return {"revision": None, "dirty": None, "diff_sha256": None, "error": str(exc)} + + +def benchmark(engine, request, *, warmup, runs, iterations): + import torch + from evaluate_multimodal import measure, quantiles + + if min(warmup, runs, iterations) <= 0: + raise ValueError("warmup, runs and iterations must be positive") + torch.cuda.synchronize() + start = time.perf_counter() + for _ in range(warmup): + engine.predict(request) + torch.cuda.synchronize() + warmup_total_ms = (time.perf_counter() - start) * 1000 + result = [] + for run in range(runs): + torch.cuda.reset_peak_memory_stats() + # Indexing drops the response immediately; measured calls have no hooks/ranges. + latencies = [ + measure(lambda: engine.predict(request))[1] for _ in range(iterations) + ] + result.append( + { + "run": run + 1, + "latencies_ms": latencies, + **quantiles(latencies), + "requests_per_second_serial": 1000 / statistics.mean(latencies), + "peak_allocated_bytes": torch.cuda.max_memory_allocated(), + "peak_reserved_bytes": torch.cuda.max_memory_reserved(), + } + ) + return {"warmup_total_ms": warmup_total_ms, "runs": result} + + +@contextmanager +def instrument(engine, record): + """Scope wrappers/hooks around existing inference, including exception cleanup.""" + modules = list(engine.model.named_modules()) + discovered = {} + for stage, leaf in [ + ("vision", "visual"), + ("language", "language_model"), + ("output_projection", "lm_head"), + ]: + matches = [ + (name, module) for name, module in modules if name.split(".")[-1] == leaf + ] + if len(matches) != 1: + raise ValueError( + f"{stage}: expected one {leaf} module, found {[n for n, _ in matches]}" + ) + discovered[stage] = matches[0][0] + active, handles, readout = [], [], [] + missing = object() + originals = { + name: engine.__dict__.get(name, missing) for name in ("prepare", "score") + } + prepare, score = engine.prepare, engine.score + + def enter(name): + span = record("cua." + name) + span.__enter__() + active.append(span) + return span + + def leave(span): + active.remove(span) + span.__exit__(*sys.exc_info()) + + def attach(module, stage, is_root=False): + spans = [] + + def before(module, inputs): + spans.append(enter(stage)) + + def after(module, inputs, output): + if spans: + leave(spans.pop()) + if is_root and output is not None: + readout.append(enter("readout")) + + handles.append(module.register_forward_pre_hook(before)) + handles.append(module.register_forward_hook(after, always_call=True)) + + class Transfer: + def __init__(self, inputs): + self.inputs = inputs + + def to(self, *args, **kwargs): + with record("cua.transfer"): + return self.inputs.to(*args, **kwargs) + + def traced_prepare(*args, **kwargs): + with record("cua.prepare"): + return prepare(*args, **kwargs) + + def traced_score(inputs, question): + try: + return score(Transfer(inputs), question) + finally: + while readout: + leave(readout.pop()) + + try: + attach(engine.model, "forward", is_root=True) + for stage, name in discovered.items(): + attach(dict(modules)[name], stage) + engine.prepare, engine.score = traced_prepare, traced_score + yield discovered + finally: + for handle in reversed(handles): + handle.remove() + while active: + leave(active[-1]) + for name, original in originals.items(): + if original is missing: + engine.__dict__.pop(name, None) + else: + setattr(engine, name, original) + + +def profile_request(engine, request, trace): + import torch + + expected = engine.predict(request) + torch.cuda.synchronize() + with ( + torch.profiler.profile( + activities=[ + torch.profiler.ProfilerActivity.CPU, + torch.profiler.ProfilerActivity.CUDA, + ], + record_shapes=True, + ) as prof, + instrument(engine, torch.profiler.record_function) as modules, + ): + actual = engine.predict(request) + torch.cuda.synchronize() + prof.export_chrome_trace(str(trace)) + if actual != expected: + raise ValueError("instrumentation parity failed (not an upstream parity check)") + operators = [ + { + "op": item.key, + "input_shapes": item.input_shapes, + "count": item.count, + "cpu_time_us": item.cpu_time_total, + "self_cpu_time_us": item.self_cpu_time_total, + "cuda_time_us": item.device_time_total, + "self_cuda_time_us": item.self_device_time_total, + } + for item in prof.key_averages(group_by_input_shape=True) + ] + stage_counts = {} + for stage in ( + "prepare", + "transfer", + "forward", + "vision", + "language", + "output_projection", + "readout", + ): + count = sum(item["count"] for item in operators if item["op"] == "cua." + stage) + if count != len(request.questions): + raise ValueError( + f"{stage}: observed {count} ranges; expected {len(request.questions)}" + ) + stage_counts[stage] = count + with trace.open("rb") as handle: + trace_sha256 = hashlib.file_digest(handle, "sha256").hexdigest() + return { + "trace": trace.name, + "trace_sha256": trace_sha256, + "trace_bytes": trace.stat().st_size, + "instrumentation_exact_parity": True, + "modules": modules, + "request_count": 1, + "forward_count": stage_counts["forward"], + "stage_counts": stage_counts, + "timing_note": "Inclusive nested ranges overlap; do not add them. CUDA times are attributed kernel durations, not wall time. Readout starts after root forward; transfer covers inputs.to().", + "operators": sorted( + operators, key=lambda x: x["self_cuda_time_us"], reverse=True + ), + } + + +def input_metadata(engine, request): + from evaluate_multimodal import fingerprint + + from models.cua_s1.multimodal.model import MAX_TOKENS + + result = [] + for question in request.questions: + inputs = engine.prepare(request.image, question) + tokens = int(inputs["input_ids"].shape[-1]) + if tokens > MAX_TOKENS: + raise ValueError( + f"{question.name}: processed prompt exceeds {MAX_TOKENS} tokens" + ) + result.append( + { + "question": question.name, + "input_tokens": tokens, + "goal_tokens": len( + engine.tokenizer.encode(question.goal, add_special_tokens=False) + ), + "inputs": fingerprint(inputs), + } + ) + return result + + +def main(argv=None): + args = parse_args(argv) + selected = [ + case for case in case_matrix() if not args.case or case["id"] in args.case + ] + if args.list_cases: + print(json.dumps(selected, indent=2)) + return 0 + if (args.output / "report.json").exists(): + raise ValueError( + "output already contains report.json; use a fresh output directory" + ) + report = { + "schema_version": 1, + "status": "running", + "repository": repository_state(Path(__file__).resolve().parents[2]), + "config": { + "warmup": args.warmup, + "runs": args.runs, + "iterations": args.iterations, + "weights": str(args.weights.resolve()), + "profile": args.profile, + "batch_size": 1, + "concurrency": 1, + "timed_scope": "engine.predict(request), synchronized; excludes parse_request and metadata preparation", + }, + "cases": [], + } + args.output.mkdir(parents=True, exist_ok=True) + write_json(args.output / "report.json", report) + current = None + try: + from evaluate_multimodal import environment, measure + + from models.cua_s1.multimodal.model import MultimodalEngine + from models.cua_s1.multimodal.protocol import parse_request + + report["environment"] = environment() + engine, report["load_ms"] = measure( + lambda: MultimodalEngine( + str(args.weights / "Qwen3.5-4B"), + str(args.weights / "cua-s1-4b-0.2/multimodal"), + ) + ) + report["adapter_modules"] = engine.adapter_modules + for case in selected: + current = {**case, "status": "running"} + report["cases"].append(current) + write_json(args.output / "report.json", report) + value = fixture(case, args.output / "fixtures") + request = parse_request(value) + current["fixture_sha256"] = hashlib.sha256( + json.dumps(value, sort_keys=True).encode() + ).hexdigest() + current["questions_metadata"] = input_metadata(engine, request) + current["input_tokens"] = sum( + q["input_tokens"] for q in current["questions_metadata"] + ) + current.update( + benchmark( + engine, + request, + warmup=args.warmup, + runs=args.runs, + iterations=args.iterations, + ) + ) + current["status"] = "complete" + write_json(args.output / f"{case['id']}.json", current) + write_json(args.output / "report.json", report) + print( + f"{case['id']}: complete ({args.runs * args.iterations} latency samples)", + flush=True, + ) + # Every baseline finishes before profiler state can affect later measurements. + for current in report["cases"]: + if current["id"] not in args.profile: + continue + value = json.loads( + (args.output / "fixtures" / f"{current['id']}.json").read_text() + ) + request = parse_request(value) + current["profile"] = profile_request( + engine, request, args.output / f"{current['id']}.trace.json" + ) + write_json(args.output / f"{current['id']}.json", current) + write_json(args.output / "report.json", report) + print(f"{current['id']}: trace complete", flush=True) + report["status"] = "complete" + except Exception as exc: # noqa: BLE001 - preserve partial results for any run failure. + error = {"type": type(exc).__name__, "message": str(exc)} + report.update(status="failed", error=error) + if current is not None: + current.update(status="failed", error=error) + write_json(args.output / f"{current['id']}.json", current) + print(f"Profiling failed: {error}", file=sys.stderr, flush=True) + return 1 + finally: + write_json(args.output / "report.json", report) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/recipe/cua_s1/profiling.md b/recipe/cua_s1/profiling.md new file mode 100644 index 0000000..0f4e0f2 --- /dev/null +++ b/recipe/cua_s1/profiling.md @@ -0,0 +1,151 @@ +# Multimodal profiling experiment + +This experiment attributes the existing unmerged BF16 Transformers/PEFT worker's +cost before changing inference. It extends the [original baseline](experiments/README.md) +with image-size, text-length and same-image question-count sweeps. It does not +implement image reuse, native CUDA kernels, CUDA Graphs or batching. + +## Hardware and environment + +Recommended for comparison with the original measurements: + +| Resource | Configuration | +| --- | --- | +| GPU | One exclusive RTX 4090, 24 GB; no competing GPU jobs | +| CPU | 8–16 allocated vCPUs; record actual thread settings | +| Host RAM | 32 GB minimum planning allowance; 64 GB preferred | +| Disk | 80–100 GB available SSD for a fresh environment, weights and traces | +| OS | Linux x86_64, Ubuntu 22.04 or 24.04 | +| Python | 3.12 | +| CUDA runtime | Match the original PyTorch `2.14.0+cu130` wheel where available | + +These are experiment planning recommendations, not measured maximum-input +requirements. The original 456-token, one-question run peaked at 8.84 GiB of +allocated GPU memory. Longer inputs and profiler tensor retention may use more. +Start with one short case before the full matrix. Stop and report an OOM rather +than silently changing precision, truncating inputs or reducing question counts. +The eight questions run serially; they are not a batch of eight. + +If reusing the previous environment and weights, substantially less free disk is +needed. Check the available space before collecting traces. A separate CUDA +Toolkit is not required for this PyTorch profiling experiment; native kernel +development is a subsequent task. CUDA 13 requires a compatible R580-or-newer +driver; the previous run used 595.71.05. See NVIDIA's +[compatibility documentation](https://docs.nvidia.com/deploy/cuda-compatibility/minor-version-compatibility.html). + +Use the [worker setup](README.md#setup) and pinned requirements. Restore the +previous environment when possible. Do not install flash-linear-attention, +causal-conv1d, merge LoRA or enable compilation in the baseline environment. +Record any environment difference and establish a new baseline before comparing +performance. GPU scheduling/allocation rules of the host still apply. + +From the repository root, with its Python environment activated: + +```sh +nvidia-smi --query-gpu=name,memory.total,memory.used,driver_version --format=csv +df -h . +python -c 'import torch; print(torch.__version__, torch.version.cuda, torch.cuda.is_available())' +python -m pip freeze > /tmp/cua-profile-packages.txt +PYTHONPATH=src python recipe/cua_s1/download_weights.py --dest weights +PYTHONPATH=src python -m pytest tests/cua_s1 -q +``` + +The downloader verifies pinned sizes and hashes. Existing valid weights can be +reused. Keep model weights outside version control and select the allocated GPU +with `CUDA_VISIBLE_DEVICES` when appropriate. + +## Hypotheses and controls + +1. Repeated questions about one image repeat image preprocessing and vision + computation. Measure how much those stages contribute before implementing + reuse; do not assume they dominate. +2. Longer instructions and larger processed image grids change the mix of vision, + language and projection work. Record actual token counts and tensor shapes; + the fixture names are input categories, not promised token lengths. +3. The trace instrumentation should preserve the response exactly. Comparing + traced and ordinary responses is an instrumentation check, not an independent + upstream parity result. + +Keep the GPU, model revisions, package versions, BF16 dtype, unmerged adapter, +full-logit path, thread configuration and serial execution fixed. Correctness +against the pinned upstream implementation remains the separate +[`evaluate_multimodal.py` reference/candidate procedure](README.md#reproduce-correctness-and-profiling). +Run those modes before accepting a new environment or inference change. Do not +use old GPU reports as evidence for a newly changed path. + +## Run + +List the 16 cases without importing PyTorch or loading weights: + +```sh +PYTHONPATH=src python recipe/cua_s1/profile_multimodal.py --list-cases +``` + +The matrix covers 320×240 and 640×480 PNGs, short/long instructions and 1/2/4/8 +questions per request. Each request uses a single synthetic image with three +candidate actions per question. Images contain no private user data. + +Start with a feasibility run, using a new output directory: + +```sh +PYTHONPATH=src python recipe/cua_s1/profile_multimodal.py \ + --weights weights --output /tmp/cua-profile-smoke \ + --case 320x240-short-q1 --profile 320x240-short-q1 \ + --warmup 1 --runs 1 --iterations 2 +``` + +This checks execution and trace generation; two samples are not a performance +claim. Next run the complete matrix, profiling only two representative cases: + +```sh +PYTHONPATH=src python recipe/cua_s1/profile_multimodal.py \ + --weights weights --output /tmp/cua-profile-measured \ + --profile 640x480-short-q1 --profile 640x480-short-q8 \ + --warmup 5 --runs 2 --iterations 50 +``` + +Use repeated `--case` arguments for a selected subset. Retain both successful +and failed-run manifests. A failed case must be investigated before claiming +coverage of the full matrix. Reserve detailed traces for selected cases: shape +recording adds overhead and memory pressure. + +Completed cases are written before the next case begins. Measurements within a +case are saved after all its runs finish; an interruption during that case can +lose its samples. This script does not resume a partial run. Repeat the failed +case in a new output directory and retain the original failure record. + +## Interpretation and publication + +The unprofiled benchmark times `engine.predict` after JSON parsing and image +decoding, with CUDA synchronization at the boundaries. It includes processor +work, transfers, forward passes, candidate readout and response construction. +It excludes HTTP, admission/queueing, input decoding, load, setup metadata and +profiler overhead. Startup and per-case warmup are separate observations. + +Each case retains raw latency samples and reports p50/p95, serial request rate, +question count and GPU memory peaks. Serial question rate, if derived, is request +rate multiplied by question count; it is not independent concurrent throughput. +Do not infer p99 reliability or GUI task quality from these measurements. + +Trace ranges and grouped operators describe instrumented execution. Inclusive +stage ranges overlap with child operations and kernels; do not sum them or use +their totals as fractions of the unprofiled request time. CPU range duration is +not necessarily GPU execution time. Module-name discovery must identify the +vision, language and output-head boundaries explicitly. Missing boundaries are +an experiment failure, not zero time. See the +[PyTorch profiler documentation](https://docs.pytorch.org/docs/stable/profiler) +for shape-recording overhead and trace semantics. + +For a reviewable experiment PR, include: + +- Commit/source provenance, environment, exact commands and fixture settings. +- New upstream reference/candidate parity results, or a clear statement that + they were not rerun. +- Both warm runs' raw samples, numerical summaries, memory peaks and stage/module + mappings; document all exclusions and failed cases. +- A bounded next optimization hypothesis supported by the profile. + +Keep large Chrome traces outside Git, with checksums in the experiment record. +Publish no speedup until an optimized implementation has a paired comparison +against this baseline. Native interface design, image reuse and kernel changes +remain separate follow-ups. diff --git a/tests/cua_s1/test_profiling.py b/tests/cua_s1/test_profiling.py new file mode 100644 index 0000000..70e5b1c --- /dev/null +++ b/tests/cua_s1/test_profiling.py @@ -0,0 +1,392 @@ +"""CPU contracts for the profiling harness; no weights or torch installation required.""" + +import importlib.util +import json +import subprocess +import sys +from contextlib import contextmanager +from pathlib import Path +from types import SimpleNamespace + +import pytest + +RECIPE = Path(__file__).resolve().parents[2] / "recipe/cua_s1" + + +@pytest.fixture +def profiling(monkeypatch): + path = RECIPE / "profile_multimodal.py" + assert path.exists(), "profiling harness is not implemented" + monkeypatch.syspath_prepend(str(RECIPE)) + spec = importlib.util.spec_from_file_location("profiling", path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def test_matrix_is_deterministic_and_valid(profiling, tmp_path): + from models.cua_s1.multimodal.protocol import parse_request + + matrix = profiling.case_matrix() + assert len(matrix) == len({c["id"] for c in matrix}) == 16 + assert matrix[-1]["id"] == "640x480-long-q8" + for case in matrix: + one = profiling.fixture(case, tmp_path / "one") + two = profiling.fixture(case, tmp_path / "two") + assert one == two + request = parse_request(one) + assert request.image.size == tuple(case["size"]) + assert len(request.questions) == case["questions"] + assert len({q.goal for q in request.questions}) == 1 + assert len(request.questions[0].goal) < 16384 + + +@pytest.mark.parametrize("option", ["--warmup", "--runs", "--iterations"]) +@pytest.mark.parametrize("value", ["0", "-1"]) +def test_nonpositive_counts_are_rejected(profiling, option, value): + with pytest.raises(SystemExit): + profiling.parse_args(["--list-cases", option, value]) + + +@pytest.mark.parametrize( + "selectors", + [ + ["--case", "unknown"], + ["--case", "320x240-short-q1", "--case", "320x240-short-q1"], + ["--profile", "unknown"], + ["--profile", "320x240-short-q1", "--profile", "320x240-short-q1"], + ["--case", "320x240-short-q1", "--profile", "640x480-long-q8"], + ], +) +def test_invalid_selection_rejected(profiling, selectors): + with pytest.raises(SystemExit): + profiling.parse_args(["--list-cases", *selectors]) + + +def test_help_and_list_cases_do_not_import_torch(profiling): + for flag in ["--help", "--list-cases"]: + command = ( + "import runpy,sys;sys.modules['torch']=None;" + f"sys.path.insert(0,{str(RECIPE)!r});" + f"sys.argv=['profile_multimodal.py',{flag!r}];" + f"runpy.run_path({str(RECIPE / 'profile_multimodal.py')!r},run_name='__main__')" + ) + result = subprocess.run( + [sys.executable, "-c", command], capture_output=True, text=True, check=False + ) + assert result.returncode == 0, result.stderr + assert "320x240-short-q1" in result.stdout or flag == "--help" + + +def test_measurement_accounting_and_synchronization(profiling, monkeypatch): + events = [] + cuda = SimpleNamespace( + synchronize=lambda: events.append("sync"), + reset_peak_memory_stats=lambda: events.append("reset"), + max_memory_allocated=lambda: 100, + max_memory_reserved=lambda: 200, + ) + monkeypatch.setitem(sys.modules, "torch", SimpleNamespace(cuda=cuda)) + engine = SimpleNamespace(predict=lambda request: events.append("predict")) + result = profiling.benchmark(engine, object(), warmup=2, runs=2, iterations=3) + assert result["warmup_total_ms"] >= 0 + assert len(result["runs"]) == 2 + assert all(len(run["latencies_ms"]) == 3 for run in result["runs"]) + assert ( + events + == ["sync", "predict", "predict", "sync", "reset"] + + ["sync", "predict", "sync"] * 3 + + ["reset"] + + ["sync", "predict", "sync"] * 3 + ) + assert all(run["peak_allocated_bytes"] == 100 for run in result["runs"]) + + +class Module: + def __init__(self, name, events, fail=False): + self.name, self.events, self.fail = name, events, fail + self.pre, self.post = [], [] + self.children = [] + + def named_modules(self): + return iter([(self.name, self), *self.children]) + + def register_forward_pre_hook(self, hook): + self.pre.append(hook) + return SimpleNamespace(remove=lambda: self.pre.remove(hook)) + + def register_forward_hook(self, hook, always_call=False): + assert always_call + self.post.append(hook) + return SimpleNamespace(remove=lambda: self.post.remove(hook)) + + def __call__(self): + output = None + try: + for hook in self.pre: + hook(self, ()) + for _, child in self.children: + child() + if self.fail: + raise RuntimeError("forward failed") + output = "output" + return output + finally: + for hook in self.post: + hook(self, (), output) + + +def fake_engine(events, fail=False): + root = Module("", events) + root.children = [ + (name, Module(name, events, fail=fail and name == "visual")) + for name in ("visual", "language_model", "lm_head") + ] + + class Engine: + model = root + + def prepare(self, image, question): + return SimpleNamespace(to=lambda device: events.append("transfer")) + + def score(self, inputs, question): + inputs.to("cuda") + self.model() + events.append("readout") + return [1.0] + + def predict(self, request): + return self.score(self.prepare(None, None), None) + + return Engine() + + +@pytest.mark.parametrize("fail", [False, True]) +def test_instrumentation_is_scoped_and_ranges_close(profiling, fail): + events, active = [], [] + engine = fake_engine(events, fail) + original = dict(engine.__dict__) + + @contextmanager + def record(name): + active.append(name) + events.append("enter:" + name) + try: + yield + finally: + assert active.pop() == name + events.append("exit:" + name) + + try: + with profiling.instrument(engine, record) as discovered: + assert set(discovered) >= {"vision", "language", "output_projection"} + assert engine.predict(None) == [1.0] + except RuntimeError: + assert fail + assert not active + assert engine.__dict__ == original + assert all(not m.pre and not m.post for _, m in engine.model.named_modules()) + assert "enter:cua.prepare" in events + assert "enter:cua.transfer" in events + if not fail: + assert ( + events.index("enter:cua.readout") + < events.index("readout") + < events.index("exit:cua.readout") + ) + events.clear() + engine.predict(None) + assert events == ["transfer", "readout"] + + +def test_missing_modules_fail_before_installing_hooks(profiling): + engine = fake_engine([]) + engine.model.children.pop() + with ( + pytest.raises(ValueError, match="output_projection"), + profiling.instrument(engine, None), + ): + pass + assert all(not m.pre and not m.post for _, m in engine.model.named_modules()) + + +def test_provenance_hash_includes_untracked_sources(profiling, tmp_path): + subprocess.run(["git", "init", "-q", str(tmp_path)], check=True) + subprocess.run( + [ + "git", + "-C", + str(tmp_path), + "-c", + "user.name=Test", + "-c", + "user.email=test@example.com", + "commit", + "--allow-empty", + "-qm", + "initial", + ], + check=True, + ) + path = tmp_path / "new.py" + path.write_text("one") + first = profiling.repository_state(tmp_path) + path.write_text("two") + second = profiling.repository_state(tmp_path) + assert first["dirty"] and second["dirty"] + assert first["diff_sha256"] != second["diff_sha256"] + assert first["revision"] == second["revision"] + assert json.loads(json.dumps(second)) == second + + +@pytest.mark.parametrize("profile_fails", [False, True]) +def test_all_baselines_precede_profiles_and_results_survive_failure( + profiling, monkeypatch, tmp_path, profile_fails +): + import evaluate_multimodal + + from models.cua_s1.multimodal import model + + events = [] + engine = SimpleNamespace(adapter_modules=178) + monkeypatch.setattr(model, "MultimodalEngine", lambda *args: engine) + monkeypatch.setattr(evaluate_multimodal, "environment", lambda: {"gpu": "fake"}) + monkeypatch.setattr(evaluate_multimodal, "measure", lambda call: (call(), 1.0)) + monkeypatch.setattr( + profiling, "repository_state", lambda root: {"revision": "fake"} + ) + monkeypatch.setattr( + profiling, "input_metadata", lambda *args: [{"input_tokens": 42}] + ) + + def benchmark(*args, **kwargs): + events.append("baseline") + return {"warmup_total_ms": 1.0, "runs": [{"latencies_ms": [1.0]}]} + + def profile(*args): + events.append("profile") + if profile_fails: + raise RuntimeError("profile failed") + return {"instrumentation_exact_parity": True} + + monkeypatch.setattr(profiling, "benchmark", benchmark) + monkeypatch.setattr(profiling, "profile_request", profile) + first, second = "320x240-short-q1", "320x240-short-q2" + code = profiling.main( + [ + "--weights", + str(tmp_path / "weights"), + "--output", + str(tmp_path), + "--case", + first, + "--case", + second, + "--profile", + first, + ] + ) + assert events == ["baseline", "baseline", "profile"] + assert code == int(profile_fails) + report = json.loads((tmp_path / "report.json").read_text()) + assert report["status"] == ("failed" if profile_fails else "complete") + assert json.loads((tmp_path / f"{second}.json").read_text())["status"] == "complete" + saved = json.loads((tmp_path / f"{first}.json").read_text()) + assert saved["runs"] == [{"latencies_ms": [1.0]}] + if profile_fails: + assert saved["error"]["message"] == "profile failed" + + +@pytest.mark.parametrize("missing_stage", [None, "vision"]) +def test_trace_has_shapes_times_checksum_and_exact_parity( + profiling, monkeypatch, tmp_path, missing_stage +): + import hashlib + + events = [] + engine = fake_engine(events) + + @contextmanager + def record(name): + yield + + class Profiler: + def __enter__(self): + events.append("profiler") + return self + + def __exit__(self, *args): + pass + + def export_chrome_trace(self, path): + Path(path).write_bytes(b"trace") + + def key_averages(self, group_by_input_shape): + assert group_by_input_shape + return [ + SimpleNamespace( + key=key, + input_shapes=[[1, 2]], + count=1, + cpu_time_total=8, + self_cpu_time_total=3, + device_time_total=6, + self_device_time_total=2, + ) + for key in ["op"] + + [ + "cua." + name + for name in [ + "prepare", + "transfer", + "forward", + "vision", + "language", + "output_projection", + "readout", + ] + if name != missing_stage + ] + ] + + def start(**kwargs): + assert kwargs["record_shapes"] is True + return Profiler() + + torch = SimpleNamespace( + cuda=SimpleNamespace(synchronize=lambda: None), + profiler=SimpleNamespace( + profile=start, + record_function=record, + ProfilerActivity=SimpleNamespace(CPU="cpu", CUDA="cuda"), + ), + ) + monkeypatch.setitem(sys.modules, "torch", torch) + if missing_stage: + with pytest.raises(ValueError, match="vision.*0.*1"): + profiling.profile_request( + engine, SimpleNamespace(questions=[None]), tmp_path / "trace.json" + ) + return + result = profiling.profile_request( + engine, SimpleNamespace(questions=[None]), tmp_path / "trace.json" + ) + assert events[:3] == ["transfer", "readout", "profiler"] + assert result["instrumentation_exact_parity"] is True + assert result["forward_count"] == 1 + assert result["stage_counts"] == { + name: 1 + for name in [ + "prepare", + "transfer", + "forward", + "vision", + "language", + "output_projection", + "readout", + ] + } + assert result["trace_sha256"] == hashlib.sha256(b"trace").hexdigest() + assert result["trace_bytes"] == 5 + assert result["operators"][0]["input_shapes"] == [[1, 2]] + assert result["operators"][0]["self_cuda_time_us"] == 2 From ebd7adc7e43d1c8ef2144cc0426295bf22abfa3b Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 11:21:43 +0800 Subject: [PATCH 03/26] Distinguish profiler device annotations and support trace-only runs --- recipe/cua_s1/profile_multimodal.py | 60 +++++++++++++++------- recipe/cua_s1/profiling.md | 30 ++++++++++- tests/cua_s1/test_profiling.py | 79 ++++++++++++++++++++++++++++- 3 files changed, 150 insertions(+), 19 deletions(-) diff --git a/recipe/cua_s1/profile_multimodal.py b/recipe/cua_s1/profile_multimodal.py index 3b66695..38a6b59 100644 --- a/recipe/cua_s1/profile_multimodal.py +++ b/recipe/cua_s1/profile_multimodal.py @@ -50,6 +50,11 @@ def parse_args(argv=None): parser.add_argument("--weights", type=Path) parser.add_argument("--output", type=Path) parser.add_argument("--list-cases", action="store_true") + parser.add_argument( + "--trace-only", + action="store_true", + help="trace selected --profile cases without baseline measurements", + ) parser.add_argument( "--case", action="append", default=[], help="case id; repeatable" ) @@ -72,6 +77,12 @@ def parse_args(argv=None): parser.error(f"--{name} contains duplicate or unknown case ids") if set(args.profile) - set(args.case or known): parser.error("--profile cases must also be selected by --case") + if args.trace_only and ( + not args.profile or (args.case and set(args.case) != set(args.profile)) + ): + parser.error( + "--trace-only requires --profile; when supplied, --case must match --profile exactly" + ) if not args.list_cases and (args.weights is None or args.output is None): parser.error("--weights and --output are required unless --list-cases is used") return args @@ -250,6 +261,8 @@ def profile_request(engine, request, trace): operators = [ { "op": item.key, + "device_type": str(item.device_type), + "is_user_annotation": item.is_user_annotation, "input_shapes": item.input_shapes, "count": item.count, "cpu_time_us": item.cpu_time_total, @@ -269,7 +282,13 @@ def profile_request(engine, request, trace): "output_projection", "readout", ): - count = sum(item["count"] for item in operators if item["op"] == "cua." + stage) + count = sum( + item["count"] + for item in operators + if item["op"] == "cua." + stage + and item["device_type"] == "DeviceType.CPU" + and item["is_user_annotation"] + ) if count != len(request.questions): raise ValueError( f"{stage}: observed {count} ranges; expected {len(request.questions)}" @@ -284,9 +303,10 @@ def profile_request(engine, request, trace): "instrumentation_exact_parity": True, "modules": modules, "request_count": 1, + "uninstrumented_reference_requests": 1, "forward_count": stage_counts["forward"], "stage_counts": stage_counts, - "timing_note": "Inclusive nested ranges overlap; do not add them. CUDA times are attributed kernel durations, not wall time. Readout starts after root forward; transfer covers inputs.to().", + "timing_note": "Count invocations from CPU user annotations only. CPU and CUDA rows with the same name are distinct views, not additional invocations; do not add their durations. Inclusive nested ranges overlap. CUDA fields are raw profiler aggregates and may include synthetic annotations, not disjoint kernel time or wall time. Readout starts after root forward; transfer covers inputs.to().", "operators": sorted( operators, key=lambda x: x["self_cuda_time_us"], reverse=True ), @@ -321,8 +341,9 @@ def input_metadata(engine, request): def main(argv=None): args = parse_args(argv) + selectors = args.profile if args.trace_only else args.case selected = [ - case for case in case_matrix() if not args.case or case["id"] in args.case + case for case in case_matrix() if not selectors or case["id"] in selectors ] if args.list_cases: print(json.dumps(selected, indent=2)) @@ -333,17 +354,20 @@ def main(argv=None): ) report = { "schema_version": 1, + "mode": "trace-only" if args.trace_only else "benchmark", "status": "running", "repository": repository_state(Path(__file__).resolve().parents[2]), "config": { - "warmup": args.warmup, - "runs": args.runs, - "iterations": args.iterations, + "warmup": 0 if args.trace_only else args.warmup, + "runs": 0 if args.trace_only else args.runs, + "iterations": 0 if args.trace_only else args.iterations, "weights": str(args.weights.resolve()), "profile": args.profile, "batch_size": 1, "concurrency": 1, - "timed_scope": "engine.predict(request), synchronized; excludes parse_request and metadata preparation", + "timed_scope": None + if args.trace_only + else "engine.predict(request), synchronized; excludes parse_request and metadata preparation", }, "cases": [], } @@ -377,20 +401,21 @@ def main(argv=None): current["input_tokens"] = sum( q["input_tokens"] for q in current["questions_metadata"] ) - current.update( - benchmark( - engine, - request, - warmup=args.warmup, - runs=args.runs, - iterations=args.iterations, + if not args.trace_only: + current.update( + benchmark( + engine, + request, + warmup=args.warmup, + runs=args.runs, + iterations=args.iterations, + ) ) - ) - current["status"] = "complete" + current["status"] = "prepared" if args.trace_only else "complete" write_json(args.output / f"{case['id']}.json", current) write_json(args.output / "report.json", report) print( - f"{case['id']}: complete ({args.runs * args.iterations} latency samples)", + f"{case['id']}: {current['status']} ({0 if args.trace_only else args.runs * args.iterations} latency samples)", flush=True, ) # Every baseline finishes before profiler state can affect later measurements. @@ -404,6 +429,7 @@ def main(argv=None): current["profile"] = profile_request( engine, request, args.output / f"{current['id']}.trace.json" ) + current["status"] = "complete" write_json(args.output / f"{current['id']}.json", current) write_json(args.output / "report.json", report) print(f"{current['id']}: trace complete", flush=True) diff --git a/recipe/cua_s1/profiling.md b/recipe/cua_s1/profiling.md index 0f4e0f2..e009476 100644 --- a/recipe/cua_s1/profiling.md +++ b/recipe/cua_s1/profiling.md @@ -83,7 +83,12 @@ PYTHONPATH=src python recipe/cua_s1/profile_multimodal.py --list-cases The matrix covers 320×240 and 640×480 PNGs, short/long instructions and 1/2/4/8 questions per request. Each request uses a single synthetic image with three -candidate actions per question. Images contain no private user data. +candidate actions per question. Questions within a case repeat the same +instruction and criteria under different question names, isolating question +count from prompt variation. The long instruction repeats a fixed sentence 64 +times; it is a controlled workload, not a realistic GUI task evaluation. Images +contain no private user data. Follow-up reuse correctness tests must also cover +different questions sharing an image. Start with a feasibility run, using a new output directory: @@ -114,6 +119,20 @@ case are saved after all its runs finish; an interruption during that case can lose its samples. This script does not resume a partial run. Repeat the failed case in a new output directory and retain the original failure record. +If latency sampling completed but trace collection needs to be repeated, use a +separate trace-only run after fixing the failure: + +```sh +PYTHONPATH=src python recipe/cua_s1/profile_multimodal.py \ + --weights weights --output /tmp/cua-profile-traces \ + --trace-only --profile 640x480-short-q1 --profile 640x480-short-q8 +``` + +Trace-only mode collects no benchmark samples and records its own source and +environment. Keep both reports; do not replace the original failed manifest or +present the new trace run as a rerun of latency measurements. If `--case` is also +specified, its set must match the `--profile` set. + ## Interpretation and publication The unprofiled benchmark times `engine.predict` after JSON parsing and image @@ -136,6 +155,15 @@ an experiment failure, not zero time. See the [PyTorch profiler documentation](https://docs.pytorch.org/docs/stable/profiler) for shape-recording overhead and trace semantics. +PyTorch can emit CPU and GPU annotations with the same range name. Operator +records retain their device type and annotation flag. Invocation counts use CPU +user annotations only; same-name GPU annotations are separate records and must +not be added again to the CPU range's attributed CUDA duration. Raw inclusive +device aggregates can themselves contain synthetic annotation accounting. Use +stage CPU spans for the host timeline and individual device kernel events in the +trace for GPU investigation; these raw parent aggregates are not disjoint kernel +time or a reliable basis for stage GPU percentages. + For a reviewable experiment PR, include: - Commit/source provenance, environment, exact commands and fixture settings. diff --git a/tests/cua_s1/test_profiling.py b/tests/cua_s1/test_profiling.py index 70e5b1c..5cd1991 100644 --- a/tests/cua_s1/test_profiling.py +++ b/tests/cua_s1/test_profiling.py @@ -326,6 +326,8 @@ def key_averages(self, group_by_input_shape): return [ SimpleNamespace( key=key, + device_type=device, + is_user_annotation=key.startswith("cua."), input_shapes=[[1, 2]], count=1, cpu_time_total=8, @@ -333,6 +335,7 @@ def key_averages(self, group_by_input_shape): device_time_total=6, self_device_time_total=2, ) + for device in ("DeviceType.CPU", "DeviceType.CUDA") for key in ["op"] + [ "cua." + name @@ -345,7 +348,7 @@ def key_averages(self, group_by_input_shape): "output_projection", "readout", ] - if name != missing_stage + if name != missing_stage or device == "DeviceType.CUDA" ] ] @@ -390,3 +393,77 @@ def start(**kwargs): assert result["trace_bytes"] == 5 assert result["operators"][0]["input_shapes"] == [[1, 2]] assert result["operators"][0]["self_cuda_time_us"] == 2 + transfer = [item for item in result["operators"] if item["op"] == "cua.transfer"] + assert len(transfer) == 2 + assert {item["device_type"] for item in transfer} == { + "DeviceType.CPU", + "DeviceType.CUDA", + } + assert all(item["is_user_annotation"] for item in transfer) + + +def test_trace_only_requires_profiles_and_exact_case_selection(profiling): + first, second = "320x240-short-q1", "320x240-short-q2" + for extra in [[], ["--profile", first, "--case", first, "--case", second]]: + with pytest.raises(SystemExit): + profiling.parse_args(["--trace-only", "--list-cases", *extra]) + args = profiling.parse_args(["--trace-only", "--list-cases", "--profile", first]) + assert args.trace_only + + +@pytest.mark.parametrize("profile_fails", [False, True]) +def test_trace_only_never_benchmarks_and_writes_fresh_report( + profiling, monkeypatch, tmp_path, profile_fails +): + import evaluate_multimodal + + from models.cua_s1.multimodal import model + + events = [] + monkeypatch.setattr( + model, "MultimodalEngine", lambda *args: SimpleNamespace(adapter_modules=178) + ) + monkeypatch.setattr(evaluate_multimodal, "environment", lambda: {"gpu": "fake"}) + monkeypatch.setattr(evaluate_multimodal, "measure", lambda call: (call(), 1.0)) + monkeypatch.setattr( + profiling, "repository_state", lambda root: {"revision": "fresh"} + ) + monkeypatch.setattr( + profiling, "input_metadata", lambda *args: [{"input_tokens": 42}] + ) + monkeypatch.setattr( + profiling, + "benchmark", + lambda *args, **kwargs: pytest.fail("trace-only must never benchmark"), + ) + + def profile(*args): + events.append("profile") + if profile_fails: + raise RuntimeError("profile failed") + return {"instrumentation_exact_parity": True} + + monkeypatch.setattr(profiling, "profile_request", profile) + case = "320x240-short-q1" + code = profiling.main( + [ + "--weights", + str(tmp_path / "weights"), + "--output", + str(tmp_path), + "--trace-only", + "--profile", + case, + ] + ) + assert events == ["profile"] + assert code == int(profile_fails) + report = json.loads((tmp_path / "report.json").read_text()) + assert report["mode"] == "trace-only" + assert report["repository"] == {"revision": "fresh"} + assert report["config"]["runs"] == report["config"]["iterations"] == 0 + assert len(report["cases"]) == 1 + assert "runs" not in report["cases"][0] + assert report["status"] == ("failed" if profile_fails else "complete") + saved = json.loads((tmp_path / f"{case}.json").read_text()) + assert saved["status"] == ("failed" if profile_fails else "complete") From 4c605e34537451e56677d9c08c47bef869ae5d68 Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 11:28:11 +0800 Subject: [PATCH 04/26] Record RTX 4090 profiling results and trace recovery --- recipe/cua_s1/experiments/README.md | 5 + .../experiments/rtx4090-profile/README.md | 178 + .../experiments/rtx4090-profile/baseline.json | 5089 ++ .../experiments/rtx4090-profile/baseline.log | 23 + .../rtx4090-profile/candidate.json | 536 + .../experiments/rtx4090-profile/packages.txt | 62 + .../rtx4090-profile/reference.json | 527 + .../rtx4090-profile/trace-archive.json | 11 + .../experiments/rtx4090-profile/traces.json | 40576 ++++++++++++++++ .../experiments/rtx4090-profile/traces.log | 12 + 10 files changed, 47019 insertions(+) create mode 100644 recipe/cua_s1/experiments/rtx4090-profile/README.md create mode 100644 recipe/cua_s1/experiments/rtx4090-profile/baseline.json create mode 100644 recipe/cua_s1/experiments/rtx4090-profile/baseline.log create mode 100644 recipe/cua_s1/experiments/rtx4090-profile/candidate.json create mode 100644 recipe/cua_s1/experiments/rtx4090-profile/packages.txt create mode 100644 recipe/cua_s1/experiments/rtx4090-profile/reference.json create mode 100644 recipe/cua_s1/experiments/rtx4090-profile/trace-archive.json create mode 100644 recipe/cua_s1/experiments/rtx4090-profile/traces.json create mode 100644 recipe/cua_s1/experiments/rtx4090-profile/traces.log diff --git a/recipe/cua_s1/experiments/README.md b/recipe/cua_s1/experiments/README.md index f1df428..ae1e0ef 100644 --- a/recipe/cua_s1/experiments/README.md +++ b/recipe/cua_s1/experiments/README.md @@ -1,5 +1,10 @@ # RTX 4090 multimodal validation — 2026-09-27 +For the subsequent 16-case stage profiling experiment, refreshed upstream parity, +and profiler annotation-counting recovery, see the +[2026-09-28 report](rtx4090-profile/README.md). The measurements below remain the +original baseline and have not been replaced. + This is a Transformers/PEFT CUDA baseline, with the adapter unmerged and full logits, for the screenshot worker in [the recipe](../README.md). It does not implement a native CUDA backend or claim a speedup over upstream. diff --git a/recipe/cua_s1/experiments/rtx4090-profile/README.md b/recipe/cua_s1/experiments/rtx4090-profile/README.md new file mode 100644 index 0000000..85963e9 --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-profile/README.md @@ -0,0 +1,178 @@ +# RTX 4090 multimodal profiling — 2026-09-28 + +This is a stage-level baseline of the existing Transformers/PEFT worker, not an +optimized implementation or a speedup claim. Source commit: +`767e21172a303e36da4765fe59027db63f09acd1`; the remote checkout was clean. Model execution +is unchanged from PR #12's `ee970c2`. The 9-question upstream parity check was rerun +at `ee970c2` before the profiling harness was added. Trace collection was repeated +at `ebd7adc7e43d1c8ef2144cc0426295bf22abfa3b` after fixing CPU/GPU annotation counting; +model execution and the latency measurement function were not changed by that fix. + +## Preserved failure and recovery + +All 16 cases completed their latency samples before the first trace failed its +stage-count check: PyTorch emits separate CPU and GPU annotations under the same +name, and the original check added both. The original [baseline.json](baseline.json) +and [baseline.log](baseline.log) retain their failed status and error. Their +**1,600 unprofiled samples are complete**, independently checked for sample counts +and percentile calculations; they were collected before the profiler ran. + +The fix retains event device types, counts CPU user annotations only, and supports +an explicit trace-only run. [traces.json](traces.json) records the successful new +trace run, its own clean source revision and environment. It contains no benchmark +samples. Its fixture and prepared-input fingerprints match the corresponding +baseline cases. The failed manifest has not been relabeled or overwritten. + +## Environment and method + +- RTX 4090, 24,564 MiB; driver 595.71.05, CUDA runtime 13.0. +- Linux container allocated 16 vCPUs and 120 GiB RAM. PyTorch intra/inter-op + thread counts remain 64/64, matching the earlier environment; no thread tuning. +- Python 3.12.13, unmerged BF16 base with PEFT fp32 LoRA branches; + all 178 expected adapted modules loaded. Full-logit scoring and PyTorch + Gated DeltaNet/causal-convolution fallbacks retained. Packages: [packages.txt](packages.txt). +- Two PNG sizes × two instruction lengths × 1/2/4/8 serial questions = 16 cases. + Instructions and candidates repeat within a case. Long instructions repeat a + fixed sentence 64 times. These are controlled synthetic workloads, not GUI accuracy tests. +- Five warmup requests per case, then two runs of 50 synchronized requests: + **1,600 measured requests / 6,000 question forwards**. All latency measurements + finish before any profiling. Raw per-case warmup and samples are in [baseline.json](baseline.json). +- Timing covers `engine.predict` after parsing/decoding; excludes HTTP, queueing, + image decoding, input fingerprinting, model load and profiling. The load + observation (19.65 s) includes artifact verification and is not + a cold-start comparison. GPU peaks below are for unprofiled execution. + +See [experiment instructions](../../profiling.md) for the complete hypothesis, +controls, setup, command sequence and measurement limitations. Exact measured command: + +```sh +PYTHONPATH=src /root/autodl-tmp/system1-omni-work/venv/bin/python \ + recipe/cua_s1/profile_multimodal.py \ + --weights /root/autodl-tmp/system1-omni-work/weights \ + --output /root/autodl-tmp/system1-omni-work/experiments/20260928-profile/measured \ + --profile 640x480-short-q1 --profile 640x480-short-q8 \ + --warmup 5 --runs 2 --iterations 50 +``` + +Trace-only recovery command, from the corrected source revision: + +```sh +PYTHONPATH=src /root/autodl-tmp/system1-omni-work/venv/bin/python \ + recipe/cua_s1/profile_multimodal.py \ + --weights /root/autodl-tmp/system1-omni-work/weights \ + --output /root/autodl-tmp/system1-omni-work/experiments/20260928-profile/traces \ + --trace-only --profile 640x480-short-q1 --profile 640x480-short-q8 +``` + +## Correctness + +- [reference.json](reference.json) and [candidate.json](candidate.json): all nine + question forwards have identical input tensor hashes and fp32 candidate + probabilities; maximum absolute difference 0. Both processes used the pinned + upstream source hash, model revisions and identical recorded environments. +- Two instrumented requests (one and eight questions) produce exactly the same + responses as ordinary execution. All seven stage ranges occur exactly once per + question. This tests instrumentation, not an independent model implementation. +- No numerical approximation, adapter merge, batching, caching or kernel change + was made. All 87 CPU tests passed on local macOS and the Linux GPU host; Ruff + checks and formatting passed locally. The added profiling suite contains 25 tests. + +## Unprofiled request latency + +Values separated by `/` are run 1 / run 2. Tokens are per question; all questions +within a case share the same prompt. p95 uses nearest rank over 50 samples. + +| Case | Tokens/question | p50 ms | p95 ms | Peak allocated GiB | +| --- | ---: | ---: | ---: | ---: | +| 320x240-short-q1 | 236 | 109.24 / 108.96 | 111.30 / 111.17 | 8.73 | +| 320x240-short-q2 | 236 | 218.49 / 218.23 | 225.28 / 229.10 | 8.73 | +| 320x240-short-q4 | 236 | 433.38 / 456.14 | 448.92 / 500.47 | 8.73 | +| 320x240-short-q8 | 236 | 905.78 / 899.87 | 984.60 / 923.22 | 8.74 | +| 320x240-long-q1 | 614 | 135.50 / 141.88 | 143.17 / 168.55 | 8.92 | +| 320x240-long-q2 | 614 | 285.31 / 283.31 | 345.52 / 348.03 | 8.93 | +| 320x240-long-q4 | 614 | 555.44 / 543.43 | 625.50 / 565.05 | 8.93 | +| 320x240-long-q8 | 614 | 1152.11 / 1116.13 | 1226.11 / 1350.77 | 8.94 | +| 640x480-short-q1 | 456 | 128.18 / 127.74 | 152.02 / 134.22 | 8.84 | +| 640x480-short-q2 | 456 | 256.98 / 255.78 | 271.74 / 272.01 | 8.85 | +| 640x480-short-q4 | 456 | 536.72 / 520.11 | 551.70 / 693.52 | 8.86 | +| 640x480-short-q8 | 456 | 1099.52 / 1106.41 | 1215.46 / 1253.40 | 8.89 | +| 640x480-long-q1 | 834 | 154.87 / 155.64 | 158.91 / 192.66 | 9.04 | +| 640x480-long-q2 | 834 | 310.97 / 310.65 | 368.06 / 326.56 | 9.04 | +| 640x480-long-q4 | 834 | 696.27 / 698.81 | 768.80 / 811.10 | 9.06 | +| 640x480-long-q8 | 834 | 1362.37 / 1393.84 | 1398.75 / 1503.62 | 9.09 | + +## Instrumented stage attribution + +Each row is an inclusive total across one profiled request. Parent ranges overlap +with child ranges; do not add these rows or combine them with operator/kernel +totals. Only CPU user-annotation rows are shown; same-name GPU annotations are +retained separately in the raw report and are not added again. CPU range time +includes host work and possible synchronization. PyTorch's raw inclusive device +aggregates can include synthetic annotation accounting; they are retained as raw +data but are not presented as stage GPU execution times. Individual device kernel +events and their shapes remain available for GPU investigation. These traces are excluded from the latency +table and do not establish production latency by themselves. + +| Case | Range | Calls | Inclusive CPU ms | +| --- | --- | ---: | ---: | +| 640x480-short-q1 | cua.prepare | 1 | 8.93 | +| 640x480-short-q1 | cua.transfer | 1 | 1.49 | +| 640x480-short-q1 | cua.forward | 1 | 222.74 | +| 640x480-short-q1 | cua.vision | 1 | 37.40 | +| 640x480-short-q1 | cua.language | 1 | 182.43 | +| 640x480-short-q1 | cua.output_projection | 1 | 0.12 | +| 640x480-short-q1 | cua.readout | 1 | 4.26 | +| 640x480-short-q8 | cua.prepare | 8 | 57.37 | +| 640x480-short-q8 | cua.transfer | 8 | 11.49 | +| 640x480-short-q8 | cua.forward | 8 | 1786.88 | +| 640x480-short-q8 | cua.vision | 8 | 291.37 | +| 640x480-short-q8 | cua.language | 8 | 1473.94 | +| 640x480-short-q8 | cua.output_projection | 8 | 0.71 | +| 640x480-short-q8 | cua.readout | 8 | 37.56 | + +Module paths, full operator shape groups, trace byte counts and SHA-256 checksums +are preserved in `traces.json`. Large Chrome traces remain outside Git, archived +alongside the experiment on the GPU host and copied locally before task completion. +Re-run the documented command to regenerate them; hashes identify the original +trace files, whose runtime timestamps are not deterministic. + +Do not rank GPU bottlenecks by CPU launch spans. In particular, the output-head +CPU span is short while its device work can continue afterward. Filtering raw +operator groups to `DeviceType.CUDA` and `is_user_annotation == false` gives +individual device kernel groups without adding CPU parents or synthetic ranges. +For example, the following GEMM groups appear in the instrumented traces: + +| Kernel group | 1-question calls / total ms | 8-question calls / total ms | +| --- | ---: | ---: | +| `ampere_bf16_s1688gemm_bf16_64x128_sliced1x2_ldg8_f2f_tn` | 96 / 16.38 | 768 / 136.14 | +| `ampere_bf16_s1688gemm_bf16_128x128_ldg8_f2f_stages_32x1_tn` | 56 / 6.54 | 448 / 52.77 | +| `ampere_bf16_s16816gemm_bf16_128x64_ldg8_f2f_tn` | 1 / 4.08 | 8 / 35.72 | + +These are instrumented kernel durations, not end-to-end latency. Kernel names +alone do not identify the owning model module; use trace correlations and shapes +before choosing a replacement kernel. + +## Next experiment + +The eight-question trace contains eight preprocessing calls and eight vision +forwards for the same image. Request-local image preprocessing and vision-feature +reuse are therefore concrete candidates for the next PR. The current data does +not measure the speedup from removing those calls. + +Start with distinct questions sharing one image, verify unchanged processor +tensors and probabilities, then run paired baseline/candidate measurements on +the same matrix. Coordinate language-layer and output-head optimizations with +the text-engine contributor. The 456-token, one-question fixture has the same +input tensor fingerprints as the original baseline; its new p50 values are +128.18 / 127.74 ms, compared with the historical 126.39 / 128.28 ms. This is a +baseline reproduction, not an optimization comparison. + +## Scope and limitations + +Results apply to this GPU, environment, synthetic input matrix and concurrency 1. +The experiment does not establish maximum supported image sizes, real task quality, +HTTP latency, p99 behavior, concurrent throughput, native CUDA or Metal support. +Reserved allocator memory can carry over between cases; allocated peaks are the +primary memory comparison. Cases execute in a fixed order, so clock/cache/order +effects have not been randomized away. Follow-up optimization claims require paired +baseline/candidate runs under the same controls and expanded reuse correctness cases. diff --git a/recipe/cua_s1/experiments/rtx4090-profile/baseline.json b/recipe/cua_s1/experiments/rtx4090-profile/baseline.json new file mode 100644 index 0000000..1e08293 --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-profile/baseline.json @@ -0,0 +1,5089 @@ +{ + "schema_version": 1, + "status": "failed", + "repository": { + "revision": "767e21172a303e36da4765fe59027db63f09acd1", + "dirty": false, + "diff_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "untracked_files": [] + }, + "config": { + "warmup": 5, + "runs": 2, + "iterations": 50, + "weights": "/root/autodl-tmp/system1-omni-work/weights", + "profile": [ + "640x480-short-q1", + "640x480-short-q8" + ], + "batch_size": 1, + "concurrency": 1, + "timed_scope": "engine.predict(request), synchronized; excludes parse_request and metadata preparation" + }, + "cases": [ + { + "id": "320x240-short-q1", + "size": [ + 320, + 240 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 1, + "status": "complete", + "fixture_sha256": "aead58362464cdd081f40f4aa18988d993e5062b24c5cdeef0e1a67b085459b5", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 236, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + } + ], + "input_tokens": 236, + "warmup_total_ms": 2085.3245314210653, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 110.21375842392445, + 109.81334187090397, + 109.19829457998276, + 109.08320173621178, + 111.30189150571823, + 109.25300791859627, + 109.19367894530296, + 109.2137498781085, + 109.20019261538982, + 109.52298156917095, + 109.4796173274517, + 109.01444684714079, + 108.74298680573702, + 109.26391743123531, + 109.31997746229172, + 109.34628546237946, + 109.16749946773052, + 109.00232940912247, + 109.08811818808317, + 109.30026322603226, + 113.31728659570217, + 110.11283099651337, + 109.0158000588417, + 109.12316851317883, + 109.39565300941467, + 109.31861773133278, + 109.31462794542313, + 109.276557341218, + 108.91090892255306, + 109.11347810178995, + 108.84407348930836, + 109.1977134346962, + 111.3800099119544, + 110.73300242424011, + 109.02496334165335, + 108.7737251073122, + 108.96614007651806, + 109.58520695567131, + 109.32122077792883, + 110.31711474061012, + 110.03441736102104, + 110.22151540964842, + 109.02069322764874, + 108.80640149116516, + 109.15777832269669, + 109.00927241891623, + 111.04845628142357, + 109.47209037840366, + 108.92680007964373, + 109.23621244728565 + ], + "p50_ms": 109.24461018294096, + "p95_ms": 111.30189150571823, + "requests_per_second_serial": 9.131260500354518, + "peak_allocated_bytes": 9371223040, + "peak_reserved_bytes": 9550430208 + }, + { + "run": 2, + "latencies_ms": [ + 109.7697215154767, + 109.26728695631027, + 109.34566799551249, + 109.12956576794386, + 109.37077179551125, + 109.23338308930397, + 109.32435747236013, + 109.14801619946957, + 109.13812182843685, + 112.36852314323187, + 110.5475639924407, + 110.35404168069363, + 109.10513531416655, + 108.87274611741304, + 109.08667556941509, + 108.73989667743444, + 108.68216399103403, + 109.00191962718964, + 109.12612359970808, + 109.28686801344156, + 108.9140111580491, + 108.83079189807177, + 108.55069663375616, + 111.1671170219779, + 108.72529912739992, + 108.11658948659897, + 107.96711966395378, + 107.97912254929543, + 108.66631660610437, + 108.35136938840151, + 108.04928094148636, + 109.9138893187046, + 108.18541143089533, + 107.99719672650099, + 108.14923699945211, + 109.0404549613595, + 108.18027425557375, + 111.4309998229146, + 107.92378336191177, + 108.08607749640942, + 108.135842718184, + 107.90623631328344, + 107.74809867143631, + 107.91924968361855, + 108.10868628323078, + 108.63486211746931, + 110.37981417030096, + 109.492102637887, + 109.52782817184925, + 110.87883356958628 + ], + "p50_ms": 108.95796539261937, + "p95_ms": 111.1671170219779, + "requests_per_second_serial": 9.171190114858026, + "peak_allocated_bytes": 9371223040, + "peak_reserved_bytes": 9550430208 + } + ] + }, + { + "id": "320x240-short-q2", + "size": [ + 320, + 240 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 2, + "status": "complete", + "fixture_sha256": "d32998f61c3f875804c0161fe9eaca360d5eae5eb6e8adebde55b969ebbf666c", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 236, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q2", + "input_tokens": 236, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + } + ], + "input_tokens": 472, + "warmup_total_ms": 1093.7979333102703, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 216.04538708925247, + 214.93373811244965, + 219.23095732927322, + 217.2668194398284, + 216.2741031497717, + 216.12192690372467, + 218.69933232665062, + 222.21833560615778, + 224.84788298606873, + 223.68280962109566, + 220.47170158475637, + 219.84144859015942, + 222.73262217640877, + 222.17827662825584, + 221.1499596014619, + 225.2725539728999, + 218.78526080399752, + 225.0996781513095, + 217.96552371233702, + 225.27570091187954, + 217.51592494547367, + 217.9378578439355, + 228.39274816215038, + 218.18385552614927, + 218.63385383039713, + 223.00243843346834, + 221.65177203714848, + 217.46406611055136, + 217.40898583084345, + 220.11577244848013, + 219.22171115875244, + 216.15939494222403, + 216.70154109597206, + 218.11743825674057, + 216.33658930659294, + 223.81509374827147, + 217.30958111584187, + 299.67067763209343, + 216.07902273535728, + 216.60633198916912, + 220.87158355861902, + 219.4976108148694, + 217.7475607022643, + 217.36395079642534, + 217.68489107489586, + 223.8267231732607, + 217.88221318274736, + 217.73004531860352, + 218.34392100572586, + 218.13040506094694 + ], + "p50_ms": 218.4888874180615, + "p95_ms": 225.27570091187954, + "requests_per_second_serial": 4.521818760151844, + "peak_allocated_bytes": 9371713024, + "peak_reserved_bytes": 9550430208 + }, + { + "run": 2, + "latencies_ms": [ + 219.5227723568678, + 218.26860029250383, + 216.9061554595828, + 220.33594828099012, + 218.28316245228052, + 226.49282310158014, + 225.686926394701, + 219.1814249381423, + 218.57981011271477, + 220.37868108600378, + 226.97950340807438, + 217.37942192703485, + 218.80255360156298, + 218.1939333677292, + 217.44008362293243, + 222.53246512264013, + 217.94068906456232, + 216.22099168598652, + 219.19746976345778, + 217.98392198979855, + 221.45340964198112, + 234.3175932765007, + 225.51661916077137, + 227.12147515267134, + 225.61059333384037, + 216.90880972892046, + 224.35851488262415, + 216.38358663767576, + 217.3525132238865, + 229.71217427402735, + 229.10095937550068, + 228.6473186686635, + 218.16612407565117, + 217.7261235192418, + 219.30176857858896, + 218.10724958777428, + 216.7628826573491, + 216.35013166815042, + 216.10972471535206, + 216.02227725088596, + 216.28253255039454, + 215.51433857530355, + 215.5065443366766, + 216.53844881802797, + 215.9966565668583, + 216.66596177965403, + 220.05982603877783, + 218.54571532458067, + 218.03305856883526, + 217.66086481511593 + ], + "p50_ms": 218.2312668301165, + "p95_ms": 229.10095937550068, + "requests_per_second_serial": 4.544569951187769, + "peak_allocated_bytes": 9371713024, + "peak_reserved_bytes": 9550430208 + } + ] + }, + { + "id": "320x240-short-q4", + "size": [ + 320, + 240 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 4, + "status": "complete", + "fixture_sha256": "04eb22230f593687092c503492c4f08a40842fac14cd51728cef51980f1078ef", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 236, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q2", + "input_tokens": 236, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q3", + "input_tokens": 236, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q4", + "input_tokens": 236, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + } + ], + "input_tokens": 944, + "warmup_total_ms": 2208.5135085508227, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 431.27171229571104, + 431.16236943751574, + 432.3650076985359, + 437.8285789862275, + 433.2777252420783, + 437.4650651589036, + 434.8971862345934, + 433.45579504966736, + 431.2144424766302, + 431.9640230387449, + 430.7343028485775, + 431.44043162465096, + 430.5736571550369, + 436.5168632939458, + 437.0213160291314, + 431.27370811998844, + 437.0431462302804, + 455.2891980856657, + 459.6038330346346, + 433.25715232640505, + 429.7408862039447, + 448.91965482383966, + 445.7050645723939, + 441.39990769326687, + 429.8449847847223, + 429.9912955611944, + 430.0107629969716, + 432.00834188610315, + 441.39538425952196, + 432.4455335736275, + 430.08256517350674, + 430.97441643476486, + 430.2990436553955, + 434.9750941619277, + 430.35716097801924, + 434.84742753207684, + 434.1838965192437, + 434.85648930072784, + 437.82956153154373, + 438.1362944841385, + 433.31175949424505, + 434.15145110338926, + 430.9576693922281, + 435.7956415042281, + 436.0181484371424, + 432.09894094616175, + 434.7128551453352, + 433.01502615213394, + 439.28625248372555, + 433.5342049598694 + ], + "p50_ms": 433.3837772719562, + "p95_ms": 448.91965482383966, + "requests_per_second_serial": 2.2979481699261832, + "peak_allocated_bytes": 9377731072, + "peak_reserved_bytes": 9550430208 + }, + { + "run": 2, + "latencies_ms": [ + 431.11209012567997, + 438.3552921935916, + 437.54910957068205, + 441.89587514847517, + 497.6724050939083, + 465.1164663955569, + 453.46023980528116, + 456.3426710665226, + 460.9727878123522, + 462.51903381198645, + 445.60145400464535, + 454.9793740734458, + 520.1561907306314, + 468.94519682973623, + 455.7452816516161, + 448.28368909657, + 453.7016786634922, + 457.17882085591555, + 468.098659068346, + 456.2492733821273, + 452.99531891942024, + 451.2535547837615, + 452.41599809378386, + 458.0361442640424, + 456.0840055346489, + 457.12713804095984, + 500.47136656939983, + 456.19423408061266, + 472.3428599536419, + 459.0183375403285, + 440.4643652960658, + 500.4504891112447, + 495.7834044471383, + 456.44715148955584, + 450.218821875751, + 450.9410122409463, + 445.9494426846504, + 455.8051861822605, + 461.96427568793297, + 438.9902912080288, + 442.6446920260787, + 439.61434438824654, + 451.56736485660076, + 456.6117376089096, + 524.5049661025405, + 492.3055740073323, + 457.09360390901566, + 456.3226876780391, + 448.4056532382965, + 455.961337313056 + ], + "p50_ms": 456.1391198076308, + "p95_ms": 500.47136656939983, + "requests_per_second_serial": 2.1727868834536066, + "peak_allocated_bytes": 9377731072, + "peak_reserved_bytes": 9550430208 + } + ] + }, + { + "id": "320x240-short-q8", + "size": [ + 320, + 240 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 8, + "status": "complete", + "fixture_sha256": "c18af7ee94cfe01f0a583e7f528e5e2e62f95a619278a49c6655e1e685f6f869", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 236, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q2", + "input_tokens": 236, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q3", + "input_tokens": 236, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q4", + "input_tokens": 236, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q5", + "input_tokens": 236, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q6", + "input_tokens": 236, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q7", + "input_tokens": 236, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q8", + "input_tokens": 236, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + } + ], + "input_tokens": 1888, + "warmup_total_ms": 4791.32636077702, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 984.5974147319794, + 901.4134621247649, + 900.3432532772422, + 905.8180181309581, + 1022.1427045762539, + 950.263224542141, + 918.6535840854049, + 900.4583982750773, + 914.079231210053, + 984.5449524000287, + 923.6044269055128, + 962.8027221187949, + 954.074140638113, + 943.0654654279351, + 912.8897627815604, + 882.1217557415366, + 913.391126319766, + 935.7405351474881, + 953.0023271217942, + 915.3247401118279, + 889.4884241744876, + 913.4222865104675, + 909.9973365664482, + 1017.2281814739108, + 916.67406167835, + 900.6088180467486, + 906.0184611007571, + 897.3203701898456, + 897.673424333334, + 900.981618091464, + 909.0002216398716, + 882.7608935534954, + 905.7348119094968, + 898.4821019694209, + 905.4064154624939, + 891.3912149146199, + 898.1148079037666, + 903.5212090238929, + 901.415060274303, + 947.0459120348096, + 869.7970127686858, + 939.7428566589952, + 865.0272442027926, + 876.517410390079, + 905.5077666416764, + 903.6626219749451, + 904.1385687887669, + 893.2191412895918, + 901.4500770717859, + 907.291604205966 + ], + "p50_ms": 905.7764150202274, + "p95_ms": 984.5974147319794, + "requests_per_second_serial": 1.0908225110051841, + "peak_allocated_bytes": 9384204800, + "peak_reserved_bytes": 9550430208 + }, + { + "run": 2, + "latencies_ms": [ + 886.6455014795065, + 923.2191909104586, + 881.5568266436458, + 906.2401363626122, + 900.3260377794504, + 895.2298406511545, + 908.7000312283635, + 926.0620987042785, + 870.7861574366689, + 916.8119989335537, + 872.0602421090007, + 922.727475874126, + 888.794083148241, + 893.1208979338408, + 898.7347269430757, + 898.0657467618585, + 902.151414193213, + 894.1773194819689, + 904.7151012346148, + 894.4488698616624, + 903.628927655518, + 914.0340769663453, + 890.9517005085945, + 907.9819582402706, + 888.3966421708465, + 929.8672843724489, + 879.7346511855721, + 916.0342486575246, + 876.3676593080163, + 901.2355301529169, + 896.7725737020373, + 898.6469581723213, + 892.9828284308314, + 905.4611045867205, + 899.8434189707041, + 905.6728081777692, + 892.8042873740196, + 899.4889380410314, + 899.9760365113616, + 899.9038692563772, + 912.3699888586998, + 896.0976330563426, + 911.5808643400669, + 918.1243535131216, + 876.8953634425998, + 917.0876061543822, + 864.0068499371409, + 901.5322951599956, + 898.2384437695146, + 901.3266768306494 + ], + "p50_ms": 899.8736441135406, + "p95_ms": 923.2191909104586, + "requests_per_second_serial": 1.1115651416220707, + "peak_allocated_bytes": 9384204800, + "peak_reserved_bytes": 9550430208 + } + ] + }, + { + "id": "320x240-long-q1", + "size": [ + 320, + 240 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 1, + "status": "complete", + "fixture_sha256": "b296166e1ccdeb4003c2c90c4b2b57335d64f657f72806fa95042a8c8d1579de", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 614, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + } + ], + "input_tokens": 614, + "warmup_total_ms": 680.2458101883531, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 135.4210153222084, + 135.8115617185831, + 135.03278605639935, + 135.12813299894333, + 135.26789844036102, + 134.8447659984231, + 135.07082872092724, + 134.73960664123297, + 134.86564625054598, + 134.8288943991065, + 135.03954280167818, + 135.4662710800767, + 134.90490522235632, + 134.8382579162717, + 137.91955169290304, + 139.84235934913158, + 143.60015653073788, + 135.7551235705614, + 135.59013977646828, + 135.42174268513918, + 135.21622493863106, + 135.01109182834625, + 134.80997364968061, + 134.96452942490578, + 134.51677467674017, + 135.0455665960908, + 135.29009092599154, + 135.6357904151082, + 135.4883210733533, + 135.57034078985453, + 135.99519152194262, + 135.7268812134862, + 143.16682796925306, + 136.3659156486392, + 135.73493342846632, + 135.50088368356228, + 135.8364773914218, + 135.5074504390359, + 135.80262195318937, + 135.68274397403002, + 135.66621206700802, + 135.4446792975068, + 135.93328557908535, + 135.47151908278465, + 135.75278781354427, + 135.70279441773891, + 135.7345310971141, + 135.6773627921939, + 140.1872979477048, + 145.6143269315362 + ], + "p50_ms": 135.50416706129909, + "p95_ms": 143.16682796925306, + "requests_per_second_serial": 7.344902164050745, + "peak_allocated_bytes": 9582139392, + "peak_reserved_bytes": 9867100160 + }, + { + "run": 2, + "latencies_ms": [ + 135.55098697543144, + 137.6044163480401, + 135.89365035295486, + 135.90197451412678, + 135.3372624143958, + 135.58031897991896, + 136.32436096668243, + 142.2440642490983, + 135.96781715750694, + 135.37447899580002, + 135.83933096379042, + 135.3864660486579, + 135.54992619901896, + 135.35532727837563, + 135.65364573150873, + 156.11941087991, + 168.54683309793472, + 145.3315168619156, + 148.04402366280556, + 142.65460614115, + 142.78501365333796, + 143.69291346520185, + 144.29203514009714, + 178.4698599949479, + 154.0191639214754, + 195.42900193482637, + 139.3091632053256, + 138.41464091092348, + 141.6396014392376, + 137.60431483387947, + 141.04418456554413, + 143.59618443995714, + 143.84784549474716, + 144.68105975538492, + 144.85450647771358, + 141.36924967169762, + 144.93818581104279, + 143.96528992801905, + 137.07328028976917, + 137.164325453341, + 143.1416980922222, + 152.72730961441994, + 142.0094696804881, + 151.7923017963767, + 141.75723306834698, + 155.17788752913475, + 138.7907788157463, + 137.44818978011608, + 147.11893443018198, + 160.74317507445812 + ], + "p50_ms": 141.88335137441754, + "p95_ms": 168.54683309793472, + "requests_per_second_serial": 6.931777375999598, + "peak_allocated_bytes": 9582139392, + "peak_reserved_bytes": 9867100160 + } + ] + }, + { + "id": "320x240-long-q2", + "size": [ + 320, + 240 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 2, + "status": "complete", + "fixture_sha256": "f540066a2fa4668efd2bcc56751f778e149db48f2491411ef5775b13b23d858b", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 614, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q2", + "input_tokens": 614, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + } + ], + "input_tokens": 1228, + "warmup_total_ms": 1728.9916053414345, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 387.74723932147026, + 306.9044863805175, + 291.7354814708233, + 282.54944179207087, + 285.2663667872548, + 278.2818702980876, + 289.18962087482214, + 291.0962337628007, + 275.9096110239625, + 280.2351741120219, + 281.88579715788364, + 283.18303637206554, + 283.2388086244464, + 281.0230692848563, + 290.1201071217656, + 292.41451527923346, + 287.1901420876384, + 281.280773691833, + 285.70971731096506, + 283.4364948794246, + 344.70862802118063, + 345.51800787448883, + 337.38096058368683, + 332.5217943638563, + 333.29643961042166, + 279.949301853776, + 278.3056618645787, + 278.23040820658207, + 291.24810732901096, + 280.2640004083514, + 282.1957180276513, + 290.21193366497755, + 282.9755637794733, + 281.57220408320427, + 281.18898440152407, + 285.5239063501358, + 291.13253578543663, + 346.94056306034327, + 280.26731964200735, + 284.91890989243984, + 280.6938160210848, + 279.80609238147736, + 288.07376231998205, + 285.3599041700363, + 292.5937492400408, + 285.4172270745039, + 283.25251769274473, + 293.53030025959015, + 287.0971877127886, + 282.8866187483072 + ], + "p50_ms": 285.31313547864556, + "p95_ms": 345.51800787448883, + "requests_per_second_serial": 3.4047281881857456, + "peak_allocated_bytes": 9584287232, + "peak_reserved_bytes": 9867100160 + }, + { + "run": 2, + "latencies_ms": [ + 285.5397304520011, + 298.1277806684375, + 304.76684030145407, + 281.1462441459298, + 284.13859847933054, + 282.91501197963953, + 283.5940681397915, + 281.84578754007816, + 276.2172194197774, + 285.1508427411318, + 279.78306356817484, + 278.11815962195396, + 280.8203734457493, + 271.1230181157589, + 282.82853215932846, + 285.26818938553333, + 288.1064247339964, + 278.2975174486637, + 283.23589637875557, + 276.8429284915328, + 288.3554492145777, + 276.2873051688075, + 271.99482172727585, + 274.22308549284935, + 279.3543031439185, + 279.2115453630686, + 291.6982863098383, + 278.8521824404597, + 282.23628271371126, + 283.3751253783703, + 285.0058628246188, + 284.1055914759636, + 284.23783648759127, + 289.9775542318821, + 285.6320207938552, + 285.5890216305852, + 280.91228287667036, + 285.0970672443509, + 276.00232791155577, + 351.038153283298, + 333.07952899485826, + 378.385204821825, + 348.02893083542585, + 324.96874034404755, + 295.96520215272903, + 283.16398337483406, + 278.86185236275196, + 279.8152230679989, + 292.3730807378888, + 275.3162533044815 + ], + "p50_ms": 283.3055108785629, + "p95_ms": 348.02893083542585, + "requests_per_second_serial": 3.455183767385667, + "peak_allocated_bytes": 9584287232, + "peak_reserved_bytes": 9867100160 + } + ] + }, + { + "id": "320x240-long-q4", + "size": [ + 320, + 240 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 4, + "status": "complete", + "fixture_sha256": "a549e1d703911d836fadbf343204ccf8b92a1f3bf244e4e9ee3507eb876b0d08", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 614, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q2", + "input_tokens": 614, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q3", + "input_tokens": 614, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q4", + "input_tokens": 614, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + } + ], + "input_tokens": 2456, + "warmup_total_ms": 2892.7241154015064, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 572.1220187842846, + 568.6004674062133, + 568.9482633024454, + 555.1696186885238, + 558.4524879232049, + 566.533355973661, + 563.5952670127153, + 570.8573088049889, + 566.4638988673687, + 563.1577968597412, + 563.1950944662094, + 565.2124565094709, + 558.9781645685434, + 559.8092135041952, + 555.7049792259932, + 561.2659882754087, + 556.7241553217173, + 551.3441255316138, + 537.9395438358188, + 538.7255940586329, + 535.6192998588085, + 539.574789814651, + 546.0446383804083, + 538.1106911227107, + 537.0455076918006, + 541.1590486764908, + 537.707700394094, + 537.9666611552238, + 536.2719455733895, + 537.1260456740856, + 546.48732021451, + 543.6785146594048, + 538.778381422162, + 538.0964893847704, + 550.0221494585276, + 538.1011953577399, + 575.0141153112054, + 653.997864574194, + 613.7713911011815, + 625.4956033080816, + 606.4772317185998, + 627.0197033882141, + 619.5015143603086, + 551.8679236993194, + 608.8858600705862, + 565.0593116879463, + 546.411095187068, + 543.1264275684953, + 549.4062704965472, + 551.5388557687402 + ], + "p50_ms": 555.4372989572585, + "p95_ms": 625.4956033080816, + "requests_per_second_serial": 1.7804896077253938, + "peak_allocated_bytes": 9593162752, + "peak_reserved_bytes": 9867100160 + }, + { + "run": 2, + "latencies_ms": [ + 552.0029636099935, + 548.1610223650932, + 554.4733423739672, + 569.8029790073633, + 548.5867382958531, + 543.1597270071507, + 540.9976560622454, + 544.2056572064757, + 542.6279529929161, + 543.6104144901037, + 543.6086375266314, + 548.2445694506168, + 542.9917154833674, + 543.2533612474799, + 545.9479205310345, + 556.6335888579488, + 546.6878358274698, + 545.2020661905408, + 553.991362452507, + 549.8393215239048, + 568.4139905497432, + 565.0521451607347, + 543.636086396873, + 554.3364994227886, + 557.4546372517943, + 540.3634337708354, + 538.4201901033521, + 545.0606206431985, + 539.9454310536385, + 540.2524909004569, + 537.7172501757741, + 544.0208883956075, + 538.3510794490576, + 538.0598157644272, + 537.2223267331719, + 542.8549163043499, + 539.8985799401999, + 537.9679165780544, + 538.8019876554608, + 539.4419245421886, + 538.805965334177, + 541.6965018957853, + 542.9879697039723, + 545.7332106307149, + 541.0603145137429, + 540.7972298562527, + 537.667672149837, + 554.149616509676, + 539.3081866204739, + 545.2063847333193 + ], + "p50_ms": 543.4309993870556, + "p95_ms": 565.0521451607347, + "requests_per_second_serial": 1.8329309741444335, + "peak_allocated_bytes": 9593162752, + "peak_reserved_bytes": 9867100160 + } + ] + }, + { + "id": "320x240-long-q8", + "size": [ + 320, + 240 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 8, + "status": "complete", + "fixture_sha256": "4594ca192ccba71269c101df00dc7c34001fea5f16195c1d3091b59234e54131", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 614, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q2", + "input_tokens": 614, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q3", + "input_tokens": 614, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q4", + "input_tokens": 614, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q5", + "input_tokens": 614, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q6", + "input_tokens": 614, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q7", + "input_tokens": 614, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + }, + { + "question": "q8", + "input_tokens": 614, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + } + ], + "input_tokens": 4912, + "warmup_total_ms": 5739.231335930526, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 1097.7909043431282, + 1103.3383095636964, + 1096.9648491591215, + 1095.0949005782604, + 1100.0113189220428, + 1105.9781508520246, + 1097.3499696701765, + 1121.6665310785174, + 1085.3282185271382, + 1137.9427500069141, + 1154.6149849891663, + 1136.8144312873483, + 1142.21709407866, + 1132.902723737061, + 1092.2909444198012, + 1112.9311667755246, + 1087.3838495463133, + 1108.6166547611356, + 1092.9682590067387, + 1108.93399361521, + 1105.7578092440963, + 1100.2404475584626, + 1091.0013057291508, + 1138.4746180847287, + 1206.2936555594206, + 1203.4601382911205, + 1205.0931919366121, + 1248.3844682574272, + 1149.6019903570414, + 1185.043953359127, + 1186.5800665691495, + 1139.3990507349372, + 1195.2995574101806, + 1180.5965108796954, + 1195.2061941847205, + 1202.114662155509, + 1226.108112372458, + 1183.3891868591309, + 1204.2148085311055, + 1195.3008770942688, + 1204.4783951714635, + 1185.6024395674467, + 1224.4125911965966, + 1208.514484576881, + 1166.5942277759314, + 1216.0086771473289, + 1206.5313309431076, + 1173.460136167705, + 1200.0664696097374, + 1270.3933669254184 + ], + "p50_ms": 1152.1084876731038, + "p95_ms": 1226.108112372458, + "requests_per_second_serial": 0.8649207773957778, + "peak_allocated_bytes": 9594391552, + "peak_reserved_bytes": 9867100160 + }, + { + "run": 2, + "latencies_ms": [ + 1416.991813108325, + 1305.2725475281477, + 1159.7932362928987, + 1159.2223634943366, + 1200.171141885221, + 1249.1042967885733, + 1157.436402514577, + 1180.0599731504917, + 1216.2562515586615, + 1179.7996629029512, + 1210.3341147303581, + 1333.8326374068856, + 1383.7030846625566, + 1190.9747030586004, + 1156.1324717476964, + 1205.8297600597143, + 1350.7674802094698, + 1175.0727631151676, + 1165.8164905384183, + 1102.7556052431464, + 1096.0749760270119, + 1101.3478245586157, + 1098.607962951064, + 1114.792707376182, + 1101.6351282596588, + 1111.287827603519, + 1100.4460081458092, + 1184.6106173470616, + 1081.8270538002253, + 1117.4722658470273, + 1080.510901287198, + 1110.322343185544, + 1097.1736274659634, + 1096.881235949695, + 1110.4562040418386, + 1102.9158048331738, + 1089.622282423079, + 1098.252171650529, + 1107.0521110668778, + 1124.116730876267, + 1202.3731591179967, + 1148.732839152217, + 1120.5186313018203, + 1097.7019043639302, + 1104.0288740769029, + 1111.891321837902, + 1081.1644801869988, + 1103.1192224472761, + 1101.3748971745372, + 1097.570912912488 + ], + "p50_ms": 1116.1324866116047, + "p95_ms": 1350.7674802094698, + "requests_per_second_serial": 0.865153553758239, + "peak_allocated_bytes": 9594391552, + "peak_reserved_bytes": 9867100160 + } + ] + }, + { + "id": "640x480-short-q1", + "size": [ + 640, + 480 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 1, + "status": "failed", + "fixture_sha256": "a531f1cbc8a5751009ab4e86b5f11cea417eb8179b117a14a63e289317b1c4f7", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + } + ], + "input_tokens": 456, + "warmup_total_ms": 642.714373767376, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 132.57829286158085, + 128.14792525023222, + 127.44792085140944, + 129.4434294104576, + 128.49150504916906, + 128.22128739207983, + 138.7832248583436, + 175.14488752931356, + 134.66631900519133, + 128.6033308133483, + 127.39017605781555, + 128.36644612252712, + 127.96738464385271, + 127.38498952239752, + 128.8349935784936, + 127.87545844912529, + 127.98150721937418, + 127.54291854798794, + 128.09507548809052, + 128.32026183605194, + 128.31980176270008, + 128.25514376163483, + 128.31255421042442, + 127.6669567450881, + 132.13999848812819, + 136.82473544031382, + 127.91622895747423, + 127.54730321466923, + 127.14837212115526, + 127.2920398041606, + 127.32278555631638, + 126.64464954286814, + 126.66001357138157, + 152.02278643846512, + 175.97630620002747, + 135.27997862547636, + 135.3281605988741, + 132.78814684599638, + 133.1102019175887, + 127.55579221993685, + 140.83301275968552, + 137.30768021196127, + 127.78085749596357, + 127.20754742622375, + 126.9161133095622, + 126.69066805392504, + 126.82127952575684, + 126.73680298030376, + 127.45955493301153, + 130.50466775894165 + ], + "p50_ms": 128.18460632115602, + "p95_ms": 152.02278643846512, + "requests_per_second_serial": 7.583044795675634, + "peak_allocated_bytes": 9495596032, + "peak_reserved_bytes": 9867100160 + }, + { + "run": 2, + "latencies_ms": [ + 135.8449338003993, + 132.77711812406778, + 134.22046601772308, + 128.2097864896059, + 127.43889354169369, + 127.3724976927042, + 127.01354175806046, + 126.68244447559118, + 132.74463079869747, + 130.59044256806374, + 127.26893927901983, + 127.84071546047926, + 127.41919327527285, + 129.15285490453243, + 128.20366211235523, + 127.60988064110279, + 130.1679778844118, + 128.90279106795788, + 128.31357400864363, + 127.80512683093548, + 127.76686530560255, + 128.00088804215193, + 127.72289663553238, + 127.88285594433546, + 128.83793376386166, + 135.95054112374783, + 129.08251769840717, + 128.16674169152975, + 127.70657707005739, + 127.19965819269419, + 127.51292996108532, + 127.26155109703541, + 127.36590951681137, + 127.12696380913258, + 127.09058821201324, + 127.28237360715866, + 127.56161950528622, + 127.2292910143733, + 127.32491455972195, + 127.64994241297245, + 127.415232360363, + 128.84226813912392, + 130.0084237009287, + 129.28524240851402, + 127.7926629409194, + 127.47650034725666, + 127.81803868710995, + 127.36308574676514, + 127.69909854978323, + 127.68926750868559 + ], + "p50_ms": 127.74488097056746, + "p95_ms": 134.22046601772308, + "requests_per_second_serial": 7.777630875270233, + "peak_allocated_bytes": 9495596032, + "peak_reserved_bytes": 9867100160 + } + ], + "error": { + "type": "ValueError", + "message": "transfer: observed 2 ranges; expected 1" + } + }, + { + "id": "640x480-short-q2", + "size": [ + 640, + 480 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 2, + "status": "complete", + "fixture_sha256": "42a2f55a81bbcee5a93b58388d1af0515f66521bc3ceaf7c14190746baa1daaf", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q2", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + } + ], + "input_tokens": 912, + "warmup_total_ms": 1346.5693788602948, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 258.97899456322193, + 258.3702318370342, + 255.28133288025856, + 254.43945359438658, + 254.51006181538105, + 253.97964287549257, + 253.87873966246843, + 259.2857526615262, + 254.8241140320897, + 255.31334523111582, + 254.86609525978565, + 254.03993483632803, + 255.15113212168217, + 255.09455054998398, + 254.6397466212511, + 254.7576231881976, + 260.00944152474403, + 271.7372588813305, + 255.36608323454857, + 257.20375776290894, + 255.15625532716513, + 262.3923197388649, + 256.5481476485729, + 258.52001644670963, + 268.4327410534024, + 276.27875097095966, + 268.5110215097666, + 274.1346098482609, + 263.7037681415677, + 259.3900505453348, + 269.22766771167517, + 266.63284096866846, + 266.69551245868206, + 263.4552353993058, + 259.2807421460748, + 259.25583951175213, + 259.3801571056247, + 261.45761273801327, + 258.289554156363, + 259.64727252721786, + 258.9429672807455, + 256.75340835005045, + 256.14837370812893, + 256.41348399221897, + 255.5900402367115, + 255.16968499869108, + 255.6227846071124, + 255.28019573539495, + 256.0803545638919, + 255.64242713153362 + ], + "p50_ms": 256.9785830564797, + "p95_ms": 271.7372588813305, + "requests_per_second_serial": 3.858095801275585, + "peak_allocated_bytes": 9501974016, + "peak_reserved_bytes": 9867100160 + }, + { + "run": 2, + "latencies_ms": [ + 259.97796189039946, + 260.372469201684, + 255.6331930682063, + 255.42616937309504, + 255.09918294847012, + 255.51069900393486, + 255.00839948654175, + 255.5904407054186, + 255.35359047353268, + 258.0652553588152, + 255.7270796969533, + 256.4041130244732, + 255.81241212785244, + 255.45431021600962, + 255.40409609675407, + 255.75076136738062, + 255.49912173300982, + 256.5548149868846, + 262.857005931437, + 255.45486994087696, + 254.14170697331429, + 254.02532424777746, + 253.70234716683626, + 254.34907525777817, + 253.599408082664, + 253.3531505614519, + 260.2378958836198, + 260.7931839302182, + 254.37840446829796, + 254.3294820934534, + 254.30440716445446, + 253.48450150340796, + 259.99000295996666, + 255.02513721585274, + 254.9911066889763, + 263.15591391175985, + 264.8947238922119, + 262.651015073061, + 265.52084647119045, + 273.0023432523012, + 268.4486713260412, + 265.6687628477812, + 267.9696725681424, + 272.01488334685564, + 267.40153320133686, + 266.16486720740795, + 271.2843166664243, + 262.0945069938898, + 271.06641698628664, + 273.7798783928156 + ], + "p50_ms": 255.78158674761653, + "p95_ms": 272.01488334685564, + "requests_per_second_serial": 3.8530361295172963, + "peak_allocated_bytes": 9501974016, + "peak_reserved_bytes": 9867100160 + } + ] + }, + { + "id": "640x480-short-q4", + "size": [ + 640, + 480 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 4, + "status": "complete", + "fixture_sha256": "6037fb3cd53ef28ce14c3d278c81974cb4bd859c15a2905de5e3bc811b77b901", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q2", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q3", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q4", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + } + ], + "input_tokens": 1824, + "warmup_total_ms": 2764.448642730713, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 539.6801000460982, + 527.7214488014579, + 536.8900848552585, + 538.4646989405155, + 536.03336494416, + 523.2989080250263, + 530.3468061611056, + 535.6822209432721, + 551.7027135938406, + 532.7213108539581, + 537.5662771984935, + 542.375834658742, + 532.385079190135, + 542.1620532870293, + 530.3526008501649, + 538.4941762313247, + 551.5771703794599, + 541.7011007666588, + 528.4035159274936, + 533.1387333571911, + 541.361247189343, + 547.513036057353, + 544.3296516314149, + 596.8365436419845, + 548.2027297839522, + 542.3556845635176, + 531.5130809322, + 537.6252057030797, + 536.4431887865067, + 534.2310480773449, + 540.834866464138, + 540.8914424479008, + 551.3800960034132, + 533.9119983837008, + 530.3058791905642, + 534.8160229623318, + 539.4576899707317, + 545.3761043027043, + 527.9811164364219, + 524.4901981204748, + 527.5215627625585, + 536.5572534501553, + 535.4896169155836, + 570.1263891533017, + 534.0512357652187, + 545.848841778934, + 537.0302060618997, + 529.2786853387952, + 526.0979607701302, + 523.3200956135988 + ], + "p50_ms": 536.7236691527069, + "p95_ms": 551.7027135938406, + "requests_per_second_serial": 1.8569497375295243, + "peak_allocated_bytes": 9517318656, + "peak_reserved_bytes": 9867100160 + }, + { + "run": 2, + "latencies_ms": [ + 536.2331103533506, + 532.3808183893561, + 637.8568699583411, + 666.8153675273061, + 693.5212658718228, + 614.5537020638585, + 589.0091555193067, + 575.657612644136, + 604.6073921024799, + 570.6598740071058, + 643.7387065961957, + 632.0535549893975, + 740.576826967299, + 725.4662280902267, + 641.1238368600607, + 684.2556027695537, + 629.3332194909453, + 685.3114748373628, + 536.6380978375673, + 534.9431140348315, + 530.8330161496997, + 531.5011693164706, + 524.5069665834308, + 526.8442211672664, + 518.8396824523807, + 520.6480948254466, + 510.3989280760288, + 511.8924183771014, + 516.891180537641, + 512.6383099704981, + 513.2433325052261, + 507.64500070363283, + 508.258568122983, + 510.93149557709694, + 519.570168107748, + 511.23964320868254, + 507.71627575159073, + 508.35820008069277, + 507.9973880201578, + 508.34221206605434, + 506.56366907060146, + 503.998851403594, + 509.0276440605521, + 508.91236029565334, + 504.0211919695139, + 505.55651541799307, + 504.4836141169071, + 508.9488858357072, + 508.0903070047498, + 504.54266369342804 + ], + "p50_ms": 520.1091314665973, + "p95_ms": 693.5212658718228, + "requests_per_second_serial": 1.7955140858238736, + "peak_allocated_bytes": 9517318656, + "peak_reserved_bytes": 9867100160 + } + ] + }, + { + "id": "640x480-short-q8", + "size": [ + 640, + 480 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 8, + "status": "complete", + "fixture_sha256": "038faab1159fdf610cb0c828b6c9e7cb12ee95a82539b9639f283530c99b5bf7", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q2", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q3", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q4", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q5", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q6", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q7", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q8", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + } + ], + "input_tokens": 3648, + "warmup_total_ms": 5714.41151201725, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 1069.7770463302732, + 1109.2627914622426, + 1093.8579235225916, + 1108.2093240693212, + 1073.469564318657, + 1011.8710855022073, + 1080.3240407258272, + 1035.3415878489614, + 1088.0918921902776, + 1110.7494235038757, + 1119.130501523614, + 1081.405045464635, + 1083.7804768234491, + 1103.6440506577492, + 1097.7759324014187, + 1102.2520055994391, + 1114.0539553016424, + 1116.7976837605238, + 1066.1842599511147, + 1100.7337179034948, + 1016.6403781622648, + 1089.3300315365195, + 1102.717679925263, + 1220.8872213959694, + 1215.4570734128356, + 1150.6669642403722, + 1121.9905652105808, + 1243.408089503646, + 1049.470053985715, + 1129.7084894031286, + 1155.4877934977412, + 1154.939690604806, + 1067.7193431183696, + 1082.9686727374792, + 1120.642769150436, + 1097.2497761249542, + 1113.465846516192, + 1097.517012618482, + 1098.473777063191, + 1103.4272331744432, + 1100.5633557215333, + 1113.6425202712417, + 1089.132709428668, + 1096.900182776153, + 1084.8249047994614, + 1102.3471727967262, + 1095.2730057761073, + 1106.4473604783416, + 1096.5395411476493, + 1098.4097495675087 + ], + "p50_ms": 1099.5185663923621, + "p95_ms": 1215.4570734128356, + "requests_per_second_serial": 0.9060767825168825, + "peak_allocated_bytes": 9546369536, + "peak_reserved_bytes": 9867100160 + }, + { + "run": 2, + "latencies_ms": [ + 1093.4698693454266, + 1114.1121303662658, + 1081.9383561611176, + 1105.810135602951, + 1105.2761003375053, + 1133.8454205542803, + 1105.4201172664762, + 1122.0151036977768, + 1096.602682955563, + 1082.9967111349106, + 1090.5241668224335, + 1105.4089153185487, + 1091.5808314457536, + 1253.402086906135, + 1177.1436734125018, + 1072.9670710861683, + 1086.2728180363774, + 1111.7400722578168, + 1299.3264887481928, + 1200.6423231214285, + 1111.979529261589, + 1131.1536962166429, + 1067.764999344945, + 1088.6437613517046, + 1107.0141438394785, + 1193.9526032656431, + 1113.9262299984694, + 1089.7712567821145, + 1102.5601234287024, + 1094.8668317869306, + 1089.899130165577, + 1122.912434861064, + 1088.9355223625898, + 1121.5908015146852, + 1098.571076989174, + 1076.9008323550224, + 1136.8465963751078, + 1159.8389819264412, + 1117.0803038403392, + 1107.921184040606, + 1187.6577800139785, + 1310.3355271741748, + 1124.0165382623672, + 1152.751674875617, + 1097.2720570862293, + 1118.6746628955007, + 1094.3760368973017, + 1118.348722346127, + 1049.799065105617, + 1081.0870733112097 + ], + "p50_ms": 1106.4121397212148, + "p95_ms": 1253.402086906135, + "requests_per_second_serial": 0.8914730632341747, + "peak_allocated_bytes": 9546369536, + "peak_reserved_bytes": 9867100160 + } + ] + }, + { + "id": "640x480-long-q1", + "size": [ + 640, + 480 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 1, + "status": "complete", + "fixture_sha256": "02daa6d5693dee5fb34786990084ae368efb181c5adbabde33392dbad2761b8b", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 834, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + } + ], + "input_tokens": 834, + "warmup_total_ms": 775.1773996278644, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 153.69473583996296, + 153.91275566071272, + 153.9694471284747, + 158.47402065992355, + 157.94397238641977, + 154.60876375436783, + 154.1861891746521, + 154.69110757112503, + 154.03260756283998, + 154.1340323165059, + 154.51048407703638, + 153.79134099930525, + 153.8402009755373, + 153.9168357849121, + 153.94473541527987, + 153.8591841235757, + 154.06038891524076, + 153.98403257131577, + 159.31641217321157, + 157.16055501252413, + 154.975482262671, + 154.69043515622616, + 154.769123531878, + 154.75463308393955, + 156.53870534151793, + 155.03530018031597, + 154.99566588550806, + 154.84648570418358, + 154.85102124512196, + 155.0878481939435, + 154.9782045185566, + 154.8674488440156, + 158.90562999993563, + 155.81493359059095, + 155.79529758542776, + 155.04423528909683, + 154.91557493805885, + 154.59225233644247, + 154.63906433433294, + 154.78022024035454, + 155.01293167471886, + 154.87449057400227, + 155.81471845507622, + 158.3401132375002, + 154.94879335165024, + 157.4221896007657, + 159.1186821460724, + 156.65732324123383, + 155.73472529649734, + 156.78055305033922 + ], + "p50_ms": 154.87096970900893, + "p95_ms": 158.90562999993563, + "requests_per_second_serial": 6.436983189470896, + "peak_allocated_bytes": 9706493952, + "peak_reserved_bytes": 10282336256 + }, + { + "run": 2, + "latencies_ms": [ + 155.24634718894958, + 155.60745354741812, + 154.9391644075513, + 154.63019907474518, + 154.92096170783043, + 154.8951156437397, + 154.86273914575577, + 157.19281882047653, + 156.88492823392153, + 155.37004452198744, + 161.56025789678097, + 167.94727090746164, + 162.62698639184237, + 156.72197472304106, + 155.78608587384224, + 159.5415873453021, + 157.00381807982922, + 155.12689296156168, + 155.01745231449604, + 155.24495113641024, + 160.2567955851555, + 158.42536836862564, + 156.00852202624083, + 155.2822357043624, + 159.15642026811838, + 155.29353450983763, + 197.9829203337431, + 192.65994429588318, + 190.83939120173454, + 197.54174258559942, + 183.663091622293, + 190.09491056203842, + 169.27879210561514, + 154.56765703856945, + 154.59240227937698, + 154.57539446651936, + 155.0982128828764, + 158.6965834721923, + 163.04300911724567, + 162.54114359617233, + 162.00512368232012, + 155.6649710983038, + 155.61086777597666, + 154.86991591751575, + 154.80395127087831, + 154.74281832575798, + 154.60408572107553, + 155.11974412947893, + 154.44007702171803, + 154.59765121340752 + ], + "p50_ms": 155.63791943714023, + "p95_ms": 192.65994429588318, + "requests_per_second_serial": 6.197949367021137, + "peak_allocated_bytes": 9706493952, + "peak_reserved_bytes": 10282336256 + } + ] + }, + { + "id": "640x480-long-q2", + "size": [ + 640, + 480 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 2, + "status": "complete", + "fixture_sha256": "ad7b074fad40228c57397f495d4f002c98f0163e66037f6c4dfefebdf2bec3cd", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 834, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q2", + "input_tokens": 834, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + } + ], + "input_tokens": 1668, + "warmup_total_ms": 1618.2407066226006, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 310.6409078463912, + 309.28322207182646, + 319.4864559918642, + 309.36920642852783, + 308.9727899059653, + 308.7984090670943, + 309.78419352322817, + 310.2570176124573, + 309.40996017307043, + 311.11183390021324, + 310.38257014006376, + 308.5936885327101, + 308.7239470332861, + 308.52718092501163, + 308.7607342749834, + 308.47238656133413, + 312.68396507948637, + 309.9094005301595, + 308.6644997820258, + 308.0876152962446, + 308.7784554809332, + 310.1505832746625, + 311.40343472361565, + 317.4201678484678, + 314.8806197568774, + 309.76371467113495, + 310.350114479661, + 309.1889312490821, + 308.7959820404649, + 308.77082981169224, + 312.0991736650467, + 317.6140272989869, + 310.82878820598125, + 317.11289566010237, + 317.97565519809723, + 311.23169232159853, + 316.7732423171401, + 321.7553002759814, + 328.44418939203024, + 388.3688598871231, + 311.266609467566, + 311.5307679399848, + 311.1670892685652, + 324.23246279358864, + 331.94479160010815, + 360.8900746330619, + 353.0105631798506, + 369.05719339847565, + 368.0552141740918, + 322.17251788824797 + ], + "p50_ms": 310.97031105309725, + "p95_ms": 368.0552141740918, + "requests_per_second_serial": 3.141699324463604, + "peak_allocated_bytes": 9710511616, + "peak_reserved_bytes": 10282336256 + }, + { + "run": 2, + "latencies_ms": [ + 309.97516959905624, + 316.5842592716217, + 309.41897071897984, + 309.734171256423, + 310.4093112051487, + 310.0055931136012, + 309.61923860013485, + 309.462902136147, + 319.1047525033355, + 311.2784344702959, + 309.6610549837351, + 309.63356234133244, + 309.5842208713293, + 309.8238641396165, + 312.3147180303931, + 315.40485844016075, + 314.56723250448704, + 315.194571390748, + 310.67938823252916, + 310.48492062836885, + 310.3097965940833, + 310.19488349556923, + 314.77775145322084, + 310.67045871168375, + 310.6291899457574, + 310.62193401157856, + 310.20266003906727, + 310.0663125514984, + 309.9973648786545, + 313.9013880863786, + 322.2860302776098, + 310.6731101870537, + 310.7066825032234, + 310.5481378734112, + 319.17004100978374, + 310.98923180252314, + 319.9342954903841, + 315.0963243097067, + 316.8289512395859, + 310.4574577882886, + 316.662585362792, + 335.93902830034494, + 326.56126376241446, + 333.29250756651163, + 310.16581505537033, + 309.46509074419737, + 309.5382545143366, + 317.98812840133905, + 320.5675557255745, + 310.5762451887131 + ], + "p50_ms": 310.64982432872057, + "p95_ms": 326.56126376241446, + "requests_per_second_serial": 3.188417693422618, + "peak_allocated_bytes": 9710511616, + "peak_reserved_bytes": 10282336256 + } + ] + }, + { + "id": "640x480-long-q4", + "size": [ + 640, + 480 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 4, + "status": "complete", + "fixture_sha256": "1c19cdfff47913f946685a1395818eb8a5fa31b1c96c2291d9ea8f28d73602eb", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 834, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q2", + "input_tokens": 834, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q3", + "input_tokens": 834, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q4", + "input_tokens": 834, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + } + ], + "input_tokens": 3336, + "warmup_total_ms": 3468.1664276868105, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 700.0775709748268, + 712.266500107944, + 626.3576708734035, + 633.198969066143, + 646.7411499470472, + 694.9493223801255, + 701.4873987063766, + 697.5867291912436, + 702.6477847248316, + 702.1122267469764, + 688.0765100941062, + 706.166960299015, + 689.4342349842191, + 702.3156778886914, + 725.4486428573728, + 686.6626739501953, + 723.372196778655, + 686.4825952798128, + 764.922215603292, + 643.3928105980158, + 670.7283398136497, + 699.3968160822988, + 700.253089889884, + 698.8100549206138, + 788.8886155560613, + 633.0244969576597, + 678.1349228695035, + 707.2991253808141, + 677.2258533164859, + 628.5090679302812, + 693.2099955156446, + 676.4742229133844, + 622.0789020881057, + 627.735173329711, + 667.1627331525087, + 699.1382325068116, + 683.2243585959077, + 623.4191218391061, + 661.3315967842937, + 647.6849354803562, + 707.8411541879177, + 700.8274663239717, + 689.1099419444799, + 712.7794083207846, + 682.0457829162478, + 701.6975516453385, + 768.8010688871145, + 766.9494356960058, + 771.5657390654087, + 720.1636508107185 + ], + "p50_ms": 696.2680257856846, + "p95_ms": 768.8010688871145, + "requests_per_second_serial": 1.4476300700791234, + "peak_allocated_bytes": 9724901888, + "peak_reserved_bytes": 10282336256 + }, + { + "run": 2, + "latencies_ms": [ + 843.1787109002471, + 839.6227145567536, + 808.74505918473, + 689.4705956801772, + 715.9173954278231, + 716.4612701162696, + 693.7212608754635, + 709.5038825646043, + 687.825994566083, + 705.5191211402416, + 692.9982481524348, + 708.5029324516654, + 696.4656272903085, + 696.9335684552789, + 681.7023726180196, + 706.8531084805727, + 692.0017786324024, + 709.8846547305584, + 669.2181928083301, + 719.5220617577434, + 695.3907068818808, + 717.24892873317, + 689.2137126997113, + 693.5274740681052, + 694.6833813562989, + 665.7315259799361, + 655.5893085896969, + 687.0856424793601, + 701.6556337475777, + 690.5151586979628, + 677.805089391768, + 652.4042766541243, + 650.3922818228602, + 734.5959888771176, + 700.6858512759209, + 710.3297170251608, + 679.087657481432, + 725.8552936837077, + 803.1794605776668, + 811.1019507050514, + 765.908227302134, + 748.6473135650158, + 646.0989909246564, + 705.6974396109581, + 713.1619788706303, + 692.6025906577706, + 683.4196383133531, + 701.9526613876224, + 724.2886452004313, + 690.8441875129938 + ], + "p50_ms": 698.8097098655999, + "p95_ms": 811.1019507050514, + "requests_per_second_serial": 1.4087384335160882, + "peak_allocated_bytes": 9724901888, + "peak_reserved_bytes": 10282336256 + } + ] + }, + { + "id": "640x480-long-q8", + "size": [ + 640, + 480 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 8, + "status": "complete", + "fixture_sha256": "458daec297c15711744c3912daaf55c4e63a27989c95f050440c6559a457dab2", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 834, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q2", + "input_tokens": 834, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q3", + "input_tokens": 834, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q4", + "input_tokens": 834, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q5", + "input_tokens": 834, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q6", + "input_tokens": 834, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q7", + "input_tokens": 834, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q8", + "input_tokens": 834, + "goal_tokens": 384, + "inputs": { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + } + ], + "input_tokens": 6672, + "warmup_total_ms": 7086.087001487613, + "runs": [ + { + "run": 1, + "latencies_ms": [ + 1390.1385329663754, + 1360.1005990058184, + 1269.577331840992, + 1363.0453730002046, + 1342.7336188033223, + 1363.232046365738, + 1393.726760521531, + 1347.8879844769835, + 1318.4220995754004, + 1379.6886736527085, + 1372.5688001140952, + 1397.9291673749685, + 1404.5342039316893, + 1391.1593426018953, + 1397.9040058329701, + 1420.0330702587962, + 1368.7132196500897, + 1393.1465623900294, + 1342.6395999267697, + 1380.4490407928824, + 1390.6797645613551, + 1354.872384108603, + 1279.3365828692913, + 1343.5093248263001, + 1256.057814694941, + 1372.0438228920102, + 1382.189012132585, + 1332.169933244586, + 1378.5239523276687, + 1328.8933569565415, + 1306.6167887300253, + 1374.7069649398327, + 1350.2254392951727, + 1320.5027906224132, + 1281.9971842691302, + 1280.809871852398, + 1385.5304485186934, + 1385.492411442101, + 1389.9678997695446, + 1398.7510232254863, + 1329.81994189322, + 1296.7571467161179, + 1344.543176703155, + 1261.2552298232913, + 1356.5902393311262, + 1336.7475466802716, + 1389.014033600688, + 1361.7014149203897, + 1272.4427785724401, + 1383.8522033765912 + ], + "p50_ms": 1362.373393960297, + "p95_ms": 1398.7510232254863, + "requests_per_second_serial": 0.7393908811881607, + "peak_allocated_bytes": 9756113408, + "peak_reserved_bytes": 10282336256 + }, + { + "run": 2, + "latencies_ms": [ + 1362.178129144013, + 1394.2665280774236, + 1339.5025487989187, + 1362.1650552377105, + 1329.1391469538212, + 1378.6236699670553, + 1410.4793155565858, + 1397.772648371756, + 1412.179159000516, + 1421.9329170882702, + 1503.622841089964, + 1406.6566955298185, + 1376.105260103941, + 1426.5071051195264, + 1396.1748043075204, + 1409.8799340426922, + 1419.2156195640564, + 1379.1582230478525, + 1389.9274244904518, + 1324.4473244994879, + 1376.903848722577, + 1332.912259735167, + 1375.6852252408862, + 1313.4083542972803, + 1394.647571258247, + 1318.0575734004378, + 1397.0009442418814, + 1397.520486265421, + 1378.1838146969676, + 1340.3055863454938, + 1718.3717787265778, + 1536.276855506003, + 1422.1456330269575, + 1395.2363152056932, + 1309.0319577604532, + 1402.9988404363394, + 1386.3290743902326, + 1286.854825913906, + 1449.8430462554097, + 1427.0371096208692, + 1437.366203404963, + 1393.4199595823884, + 1367.0230340212584, + 1404.1018476709723, + 1363.8062039390206, + 1403.7333810701966, + 1400.7476596161723, + 1384.4420788809657, + 1372.3968071863055, + 1367.3955546692014 + ], + "p50_ms": 1393.843243829906, + "p95_ms": 1503.622841089964, + "requests_per_second_serial": 0.7174309502135903, + "peak_allocated_bytes": 9756113408, + "peak_reserved_bytes": 10282336256 + } + ] + } + ], + "environment": { + "python": "3.12.13", + "gpu": "NVIDIA GeForce RTX 4090", + "compute_capability": [ + 8, + 9 + ], + "cuda": "13.0", + "driver": "595.71.05", + "torch_num_threads": 64, + "torch_num_interop_threads": 64, + "packages": { + "torch": "2.14.0", + "torchvision": "0.29.0", + "transformers": "5.17.0", + "peft": "0.21.0", + "pillow": "11.3.0", + "safetensors": "0.8.0", + "triton": "3.8.0" + }, + "reference_revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f", + "base_revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", + "adapter_revision": "16818868b0cc7813808aae4e87b417657046ab79", + "dtype": "bfloat16", + "adapter_merged": false + }, + "load_ms": 19645.041471347213, + "adapter_modules": 178, + "error": { + "type": "ValueError", + "message": "transfer: observed 2 ranges; expected 1" + } +} diff --git a/recipe/cua_s1/experiments/rtx4090-profile/baseline.log b/recipe/cua_s1/experiments/rtx4090-profile/baseline.log new file mode 100644 index 0000000..c7c3b86 --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-profile/baseline.log @@ -0,0 +1,23 @@ +[transformers] `torch_dtype` is deprecated! Use `dtype` instead! + Loading weights: 0%| | 0/723 [00:00 > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 668, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3300.540999999863, + "self_cuda_time_us": 3300.540999999863 + }, + { + "op": "aten::linalg_solve_triangular", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 4438.850000000108, + "self_cpu_time_us": 1194.7799999997878, + "cuda_time_us": 3621.558999999914, + "self_cuda_time_us": 3078.8719999999666 + }, + { + "op": "void batch_trsm_left_kernel(cublasTrsmBatchParams2, float, float const*, int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 48, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3078.8719999999666, + "self_cuda_time_us": 3078.8719999999666 + }, + { + "op": "ampere_sgemm_128x128_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 240, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3028.6990000001097, + "self_cuda_time_us": 3028.6990000001097 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 4096 + ], + [ + 4096, + 2560 + ] + ], + "count": 32, + "cpu_time_us": 1333.3310000000056, + "self_cpu_time_us": 847.5389999998442, + "cuda_time_us": 3003.4649999999237, + "self_cuda_time_us": 3003.4649999999237 + }, + { + "op": "ampere_bf16_s1688gemm_bf16_64x64_sliced1x4_ldg8_f2f_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 32, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2986.5660000000207, + "self_cuda_time_us": 2986.5660000000207 + }, + { + "op": "void at::native::unrolled_elementwise_kernel, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1> >(int, at::native::CUDAFunctor_add, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 178, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2664.5260000000017, + "self_cuda_time_us": 2664.5260000000017 + }, + { + "op": "ampere_sgemm_128x128_nn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2617.2590000000055, + "self_cuda_time_us": 2617.2590000000055 + }, + { + "op": "ampere_sgemm_128x128_nt", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2533.600000000006, + "self_cuda_time_us": 2533.600000000006 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#12}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#12}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 112, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2498.880000000019, + "self_cuda_time_us": 2498.880000000019 + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024 + ], + [ + 1200, + 4096 + ], + [ + 4096, + 1024 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 624.8219999999892, + "self_cpu_time_us": 395.2749999999869, + "cuda_time_us": 2146.819999999989, + "self_cuda_time_us": 2146.819999999989 + }, + { + "op": "void at::native::unrolled_elementwise_kernel, 4, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1> >(int, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 433, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2112.1370000000534, + "self_cuda_time_us": 2112.1370000000534 + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096 + ], + [ + 1200, + 1024 + ], + [ + 1024, + 4096 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 542.8479999999981, + "self_cpu_time_us": 401.44200000001365, + "cuda_time_us": 1965.5950000000012, + "self_cuda_time_us": 1965.5950000000012 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 388, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1964.8369999998831, + "self_cuda_time_us": 1964.8369999998831 + }, + { + "op": "aten::_flash_attention_forward", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [ + 1, + 1200, + 16, + 64 + ], + [ + 1, + 1200, + 16, + 64 + ], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 1124.5129999999845, + "self_cpu_time_us": 396.78800000004776, + "cuda_time_us": 1954.7839999999924, + "self_cuda_time_us": 1954.7839999999924 + }, + { + "op": "void pytorch_flash::flash_fwd_kernel >, false, false, false, false, false, true, false, false>(pytorch_flash::Flash_fwd_params)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1954.7839999999924, + "self_cuda_time_us": 1954.7839999999924 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 4096 + ] + ], + "count": 24, + "cpu_time_us": 395.93199999998615, + "self_cpu_time_us": 272.0910000000076, + "cuda_time_us": 1907.6529999999839, + "self_cuda_time_us": 1907.6529999999839 + }, + { + "op": "aten::bmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32, + 64, + 64 + ], + [ + 32, + 64, + 128 + ] + ], + "count": 192, + "cpu_time_us": 4458.197, + "self_cpu_time_us": 3607.4549999998417, + "cuda_time_us": 1727.1810000000842, + "self_cuda_time_us": 1727.1810000000842 + }, + { + "op": "aten::bmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32, + 128, + 64 + ], + [ + 32, + 64, + 128 + ] + ], + "count": 192, + "cpu_time_us": 4714.676999999778, + "self_cpu_time_us": 3820.2499999996217, + "cuda_time_us": 1677.4350000002014, + "self_cuda_time_us": 1677.4350000002014 + }, + { + "op": "ampere_sgemm_128x128_tt", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1677.4350000002014, + "self_cuda_time_us": 1677.4350000002014 + }, + { + "op": "ampere_sgemm_32x32_sliced1x4_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 178, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1626.0580000000555, + "self_cuda_time_us": 1626.0580000000555 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::AUnaryFunctor >, std::array, false>(int, at::native::AUnaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 208, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1566.1179999999877, + "self_cuda_time_us": 1566.1179999999877 + }, + { + "op": "ampere_sgemm_128x32_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 154, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1488.3969999998008, + "self_cuda_time_us": 1488.3969999998008 + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3072 + ], + [ + 1200, + 1024 + ], + [ + 1024, + 3072 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 546.2710000000079, + "self_cpu_time_us": 404.10899999996764, + "cuda_time_us": 1453.2719999999863, + "self_cuda_time_us": 1453.2719999999863 + }, + { + "op": "ampere_bf16_s1688gemm_bf16_128x128_ldg8_relu_f2f_stages_32x1_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1453.2719999999863, + "self_cuda_time_us": 1453.2719999999863 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::bfloat16_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda(float)#1}, std::array, false>(int, at::native::bfloat16_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 359, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1401.274000000125, + "self_cuda_time_us": 1401.274000000125 + }, + { + "op": "aten::bmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 256, + 64, + 128 + ], + [ + 256, + 128, + 64 + ] + ], + "count": 48, + "cpu_time_us": 2437.398999999983, + "self_cpu_time_us": 2178.188000000002, + "cuda_time_us": 1301.5180000000255, + "self_cuda_time_us": 1301.5180000000255 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 1, + 456, + 9216 + ], + [] + ], + "count": 64, + "cpu_time_us": 754.9209999999584, + "self_cpu_time_us": 456.68799999993644, + "cuda_time_us": 1201.0460000000603, + "self_cuda_time_us": 1201.0460000000603 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [ + 1, + 8192, + 456 + ], + [] + ], + "count": 24, + "cpu_time_us": 243.44200000001, + "self_cpu_time_us": 125.54699999999139, + "cuda_time_us": 1183.0289999999586, + "self_cuda_time_us": 1183.0289999999586 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 2, + 128 + ], + [ + 1, + 456, + 16, + 2, + 128 + ], + [] + ], + "count": 48, + "cpu_time_us": 463.56200000007084, + "self_cpu_time_us": 241.04600000006758, + "cuda_time_us": 1177.0490000000354, + "self_cuda_time_us": 1177.0490000000354 + }, + { + "op": "aten::_conv_depthwise2d", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 1, + 456 + ], + [ + 8192, + 1, + 1, + 4 + ], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 537.6839999999938, + "self_cpu_time_us": 214.4290000001056, + "cuda_time_us": 1162.3260000000373, + "self_cuda_time_us": 1162.3260000000373 + }, + { + "op": "void at::native::(anonymous namespace)::conv_depthwise2d_forward_kernel_generic(torch::headeronly::detail::GenericPackedTensorAccessor, c10::BFloat16 const, 3ul, torch::headeronly::DefaultPtrTraits, int>, at::detail::IndexBoundsCheck<4ul, int>, c10::BFloat16 const, 4ul, torch::headeronly::DefaultPtrTraits, int>, torch::headeronly::detail::GenericPackedTensorAccessor, c10::BFloat16, 3ul, torch::headeronly::DefaultPtrTraits, int>, at::detail::IndexBoundsCheck<4ul, int>, c10::BFloat16, 4ul, torch::headeronly::DefaultPtrTraits, int>, torch::headeronly::detail::GenericPackedTensorAccessor, c10::BFloat16 const, 3ul, torch::headeronly::DefaultPtrTraits, int>, at::detail::IndexBoundsCheck<4ul, int>, c10::BFloat16 const, 4ul, torch::headeronly::DefaultPtrTraits, int>, torch::headeronly::detail::GenericPackedTensorAccessor, c10::BFloat16 const, 0ul, torch::headeronly::DefaultPtrTraits, int>, at::detail::IndexBoundsCheck<1ul, int>, c10::BFloat16 const, 1ul, torch::headeronly::DefaultPtrTraits, int>, bool, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1162.3260000000373, + "self_cuda_time_us": 1162.3260000000373 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::CUDAFunctor_add, std::array, false>(int, at::native::CUDAFunctor_add, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 434, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1040.0349999998944, + "self_cuda_time_us": 1040.0349999998944 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [ + 1, + 32, + 456, + 128 + ], + [] + ], + "count": 144, + "cpu_time_us": 1324.7289999999412, + "self_cpu_time_us": 692.2179999998116, + "cuda_time_us": 1016.8729999999705, + "self_cuda_time_us": 1016.8729999999705 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "count": 72, + "cpu_time_us": 702.0959999999905, + "self_cpu_time_us": 381.7979999998497, + "cuda_time_us": 994.8280000000086, + "self_cuda_time_us": 994.8280000000086 + }, + { + "op": "cua.transfer", + "device_type": "DeviceType.CUDA", + "is_user_annotation": true, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 994.155999999999, + "self_cuda_time_us": 994.155999999999 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 152, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 985.5570000000771, + "self_cuda_time_us": 985.5570000000771 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 260, + "cpu_time_us": 2336.976000000177, + "self_cpu_time_us": 1122.048000000119, + "cuda_time_us": 926.7449999998935, + "self_cuda_time_us": 926.7449999998935 + }, + { + "op": "aten::cudnn_convolution", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3, + 2, + 16, + 16 + ], + [ + 1024, + 3, + 2, + 16, + 16 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 170.61899999999878, + "self_cpu_time_us": 119.35500000000684, + "cuda_time_us": 908.8870000000061, + "self_cuda_time_us": 908.8870000000061 + }, + { + "op": "sm80_xmma_fprop_implicit_gemm_indexed_bf16bf16_bf16f32_f32_nhwckrsc_nhwc_tilesize128x256x32_stage3_warpsize2x4x1_g1_tensor16x8x16_execute_kernel__5x_cudnn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 853.5970000000016, + "self_cuda_time_us": 853.5970000000016 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 16 + ], + [ + 16, + 9216 + ] + ], + "count": 64, + "cpu_time_us": 1008.066999999879, + "self_cpu_time_us": 724.2349999998114, + "cuda_time_us": 828.5429999999615, + "self_cuda_time_us": 828.5429999999615 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [ + 1, + 32, + 8, + 64, + 1 + ] + ], + "count": 72, + "cpu_time_us": 893.1060000000216, + "self_cpu_time_us": 575.8579999998765, + "cuda_time_us": 826.813000000082, + "self_cuda_time_us": 826.813000000082 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 1200, + 4096 + ], + [] + ], + "count": 24, + "cpu_time_us": 296.90599999996994, + "self_cpu_time_us": 182.43299999996816, + "cuda_time_us": 818.6899999999987, + "self_cuda_time_us": 818.6899999999987 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 1, + 456, + 9216 + ], + [] + ], + "count": 96, + "cpu_time_us": 845.5210000001534, + "self_cpu_time_us": 421.04100000008475, + "cuda_time_us": 778.4330000000773, + "self_cuda_time_us": 778.4330000000773 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 240, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 761.8380000000398, + "self_cuda_time_us": 761.8380000000398 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 16 + ] + ], + "count": 88, + "cpu_time_us": 2137.03499999996, + "self_cpu_time_us": 1299.0559999999823, + "cuda_time_us": 736.1450000001205, + "self_cuda_time_us": 736.1450000001205 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1536 + ], + [ + 1200, + 1536 + ], + [] + ], + "count": 2, + "cpu_time_us": 829.4700000000012, + "self_cpu_time_us": 18.80300000000716, + "cuda_time_us": 684.4330000000009, + "self_cuda_time_us": 684.4330000000009 + }, + { + "op": "Memcpy HtoD (Pageable -> Device)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 679.1529999999875, + "self_cuda_time_us": 679.1529999999875 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [] + ], + "count": 64, + "cpu_time_us": 854.4599999999627, + "self_cpu_time_us": 553.840999999913, + "cuda_time_us": 670.5119999999879, + "self_cuda_time_us": 670.5119999999879 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [ + 1, + 32, + 64, + 128 + ], + [] + ], + "count": 192, + "cpu_time_us": 2341.6920000003447, + "self_cpu_time_us": 1521.8820000002743, + "cuda_time_us": 635.0370000000257, + "self_cuda_time_us": 635.0370000000257 + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024 + ], + [ + 1200, + 1024 + ], + [ + 1024, + 1024 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 916.0350000000071, + "self_cpu_time_us": 641.7100000000537, + "cuda_time_us": 617.235000000026, + "self_cuda_time_us": 617.235000000026 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 104, + "cpu_time_us": 1240.739000000147, + "self_cpu_time_us": 761.5320000002248, + "cuda_time_us": 609.2400000000052, + "self_cuda_time_us": 609.2400000000052 + }, + { + "op": "void cutlass::Kernel2(cutlass_80_tensorop_bf16_s16816gemm_relu_bf16_64x64_32x6_tn_align8::Params)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 604.7930000000124, + "self_cuda_time_us": 604.7930000000124 + }, + { + "op": "aten::cat", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 132, + "cpu_time_us": 2166.5680000000684, + "self_cpu_time_us": 1243.7199999999575, + "cuda_time_us": 574.1060000000289, + "self_cuda_time_us": 574.1060000000289 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::FillFunctor, std::array, false>(int, at::native::FillFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 552.3560000001089, + "self_cuda_time_us": 552.3560000001089 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 16 + ], + [ + 16, + 1024 + ] + ], + "count": 16, + "cpu_time_us": 358.96699999996054, + "self_cpu_time_us": 198.65700000006473, + "cuda_time_us": 546.1430000000255, + "self_cuda_time_us": 546.1430000000255 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::CUDAFunctor_add, std::array, false>(int, at::native::CUDAFunctor_add, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 113, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 542.9529999999831, + "self_cuda_time_us": 542.9529999999831 + }, + { + "op": "ampere_sgemm_64x64_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 539.2350000000151, + "self_cuda_time_us": 539.2350000000151 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [ + 1, + 32, + 1, + 1 + ] + ], + "count": 192, + "cpu_time_us": 2246.2770000000746, + "self_cpu_time_us": 1425.2870000000112, + "cuda_time_us": 533.302999999767, + "self_cuda_time_us": 533.302999999767 + }, + { + "op": "void at::native::reduce_kernel<512, 1, at::native::ReduceOp, unsigned int, float, 4, 4> >(at::native::ReduceOp, unsigned int, float, 4, 4>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 105, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 524.1240000000253, + "self_cuda_time_us": 524.1240000000253 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [ + 14592, + 128 + ], + [] + ], + "count": 96, + "cpu_time_us": 899.2229999999836, + "self_cpu_time_us": 439.2390000001178, + "cuda_time_us": 523.8799999999901, + "self_cuda_time_us": 523.8799999999901 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [ + 1200, + 1, + 64 + ] + ], + "count": 96, + "cpu_time_us": 1118.1799999999675, + "self_cpu_time_us": 699.8469999999907, + "cuda_time_us": 498.21699999992416, + "self_cuda_time_us": 498.21699999992416 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::BinaryFunctor >, std::array, false>(int, at::native::BinaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 40, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 497.1900000000023, + "self_cuda_time_us": 497.1900000000023 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [ + 1, + 32, + 64, + 128 + ], + [] + ], + "count": 192, + "cpu_time_us": 1901.7429999999586, + "self_cpu_time_us": 1072.81200000002, + "cuda_time_us": 492.36699999994016, + "self_cuda_time_us": 492.36699999994016 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 1200, + 4096 + ], + [] + ], + "count": 48, + "cpu_time_us": 443.92199999997683, + "self_cpu_time_us": 219.5249999999687, + "cuda_time_us": 488.58799999999974, + "self_cuda_time_us": 488.58799999999974 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 9216 + ], + [ + 9216, + 16 + ] + ], + "count": 32, + "cpu_time_us": 686.4099999999889, + "self_cpu_time_us": 406.06899999997404, + "cuda_time_us": 480.7109999998356, + "self_cuda_time_us": 480.7109999998356 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [ + 1, + 32, + 128, + 128 + ], + [] + ], + "count": 192, + "cpu_time_us": 2093.656000000192, + "self_cpu_time_us": 1300.5680000003485, + "cuda_time_us": 467.1729999999952, + "self_cuda_time_us": 467.1729999999952 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 1, + 456, + 9216 + ] + ], + "count": 32, + "cpu_time_us": 380.2260000000533, + "self_cpu_time_us": 231.76500000004307, + "cuda_time_us": 466.6030000000028, + "self_cuda_time_us": 466.6030000000028 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::BinaryFunctor >, std::array, false>(int, at::native::BinaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 96, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 453.9520000000339, + "self_cuda_time_us": 453.9520000000339 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::pow_tensor_scalar_kernel_impl(at::TensorIteratorBase&, float)::{lambda(float)#1}, std::array, false>(int, at::native::(anonymous namespace)::pow_tensor_scalar_kernel_impl(at::TensorIteratorBase&, float)::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 105, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 427.21100000001024, + "self_cuda_time_us": 427.21100000001024 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [] + ], + "count": 24, + "cpu_time_us": 370.4939999999806, + "self_cpu_time_us": 258.37799999997515, + "cuda_time_us": 413.74799999999595, + "self_cuda_time_us": 413.74799999999595 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 4096, + 16 + ] + ], + "count": 24, + "cpu_time_us": 522.8689999999951, + "self_cpu_time_us": 317.29900000001726, + "cuda_time_us": 390.83400000000256, + "self_cuda_time_us": 390.83400000000256 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 1200, + 1024 + ], + [] + ], + "count": 73, + "cpu_time_us": 855.6419999999816, + "self_cpu_time_us": 523.3609999999426, + "cuda_time_us": 386.6199999999699, + "self_cuda_time_us": 386.6199999999699 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [ + 1200, + 16, + 64 + ], + [] + ], + "count": 96, + "cpu_time_us": 863.4789999999775, + "self_cpu_time_us": 440.21499999995285, + "cuda_time_us": 377.4910000000418, + "self_cuda_time_us": 377.4910000000418 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 1024 + ] + ], + "count": 16, + "cpu_time_us": 328.95100000003004, + "self_cpu_time_us": 244.71299999993062, + "cuda_time_us": 369.1410000000178, + "self_cuda_time_us": 369.1410000000178 + }, + { + "op": "ampere_bf16_s16816gemm_bf16_64x64_sliced1x2_ldg8_f2f_stages_64x5_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 369.1410000000178, + "self_cuda_time_us": 369.1410000000178 + }, + { + "op": "aten::_flash_attention_forward", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [ + 1, + 456, + 4, + 256 + ], + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 544.7569999999687, + "self_cpu_time_us": 182.34599999993225, + "cuda_time_us": 356.8880000000063, + "self_cuda_time_us": 356.8880000000063 + }, + { + "op": "aten::mean", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [] + ], + "count": 65, + "cpu_time_us": 1070.8770000002114, + "self_cpu_time_us": 765.0760000000519, + "cuda_time_us": 339.8309999999328, + "self_cuda_time_us": 339.8309999999328 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 16, + 4096 + ] + ], + "count": 24, + "cpu_time_us": 381.070999999989, + "self_cpu_time_us": 278.57899999999063, + "cuda_time_us": 337.84699999999066, + "self_cuda_time_us": 337.84699999999066 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [ + 1, + 32, + 64, + 128 + ], + [] + ], + "count": 192, + "cpu_time_us": 2152.7640000002866, + "self_cpu_time_us": 1332.8560000001307, + "cuda_time_us": 332.73799999991024, + "self_cuda_time_us": 332.73799999991024 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [] + ], + "count": 72, + "cpu_time_us": 571.7199999999211, + "self_cpu_time_us": 274.9389999999403, + "cuda_time_us": 320.06100000004517, + "self_cuda_time_us": 320.06100000004517 + }, + { + "op": "void pytorch_flash::flash_fwd_splitkv_kernel >, true, false, false, false, true, false, true, false>(pytorch_flash::Flash_fwd_params)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 297.05500000000757, + "self_cuda_time_us": 297.05500000000757 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [ + 1, + 32, + 512, + 1 + ] + ], + "count": 48, + "cpu_time_us": 551.2140000001018, + "self_cpu_time_us": 350.79700000000594, + "cuda_time_us": 296.02999999999884, + "self_cuda_time_us": 296.02999999999884 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 1 + ] + ], + "count": 65, + "cpu_time_us": 767.8999999999069, + "self_cpu_time_us": 484.78299999992305, + "cuda_time_us": 285.6010000000606, + "self_cuda_time_us": 285.6010000000606 + }, + { + "op": "void cublasLt::splitKreduce_kernel<32, 16, int, float, float, float, float, false, float, float, float, true, false, false, false>(cublasLt::cublasSplitKParams, float const*, float const*, float*, float*, float const*, float const*, float const*, float const*, float*, void*, long, float*, int*, float*, float*, float const*, float const*, float const*, float const*, float const*)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 178, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 282.23899999991045, + "self_cuda_time_us": 282.23899999991045 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560 + ] + ], + "count": 65, + "cpu_time_us": 716.7570000000342, + "self_cpu_time_us": 450.3359999999884, + "cuda_time_us": 281.4400000000387, + "self_cuda_time_us": 281.4400000000387 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [ + 1, + 32, + 456, + 1 + ] + ], + "count": 48, + "cpu_time_us": 539.322000000022, + "self_cpu_time_us": 339.92799999994895, + "cuda_time_us": 268.89700000007724, + "self_cuda_time_us": 268.89700000007724 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::CUDAFunctorOnSelf_add, std::array, false>(int, at::native::CUDAFunctorOnSelf_add, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 234, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 263.5599999995102, + "self_cuda_time_us": 263.5599999995102 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 32 + ] + ], + "count": 48, + "cpu_time_us": 1254.701000000001, + "self_cpu_time_us": 791.9920000001293, + "cuda_time_us": 257.3740000000107, + "self_cuda_time_us": 257.3740000000107 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [ + 1, + 32, + 456, + 128 + ] + ], + "count": 48, + "cpu_time_us": 564.5619999999399, + "self_cpu_time_us": 342.73899999992864, + "cuda_time_us": 255.5499999998865, + "self_cuda_time_us": 255.5499999998865 + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy, unsigned int, 3, 64, 64>(at::native::(anonymous namespace)::OpaqueType<4u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 64, 64>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 50, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 254.8530000000028, + "self_cuda_time_us": 254.8530000000028 + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy, unsigned int, 4, 64, 64>(at::native::(anonymous namespace)::OpaqueType<2u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 64, 64>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 48, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 253.0910000000149, + "self_cuda_time_us": 253.0910000000149 + }, + { + "op": "aten::sum", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 789.3550000000978, + "self_cpu_time_us": 562.470000000103, + "cuda_time_us": 246.722000000118, + "self_cuda_time_us": 246.722000000118 + }, + { + "op": "void at::native::reduce_kernel<512, 1, at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(float, float)#1}>, unsigned int, float, 4, 4> >(at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(float, float)#1}>, unsigned int, float, 4, 4>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 48, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 246.722000000118, + "self_cuda_time_us": 246.722000000118 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [ + 1200, + 16, + 64 + ], + [] + ], + "count": 48, + "cpu_time_us": 509.6259999999711, + "self_cpu_time_us": 312.0369999999857, + "cuda_time_us": 237.78899999998976, + "self_cuda_time_us": 237.78899999998976 + }, + { + "op": "aten::pow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 65, + "cpu_time_us": 1078.175000000112, + "self_cpu_time_us": 736.1700000000637, + "cuda_time_us": 236.1940000000177, + "self_cuda_time_us": 236.1940000000177 + }, + { + "op": "aten::native_layer_norm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [ + 1024 + ], + [ + 1024 + ], + [] + ], + "count": 49, + "cpu_time_us": 1514.0799999999872, + "self_cpu_time_us": 657.6240000000107, + "cuda_time_us": 228.90100000003076, + "self_cuda_time_us": 228.90100000003076 + }, + { + "op": "void at::native::(anonymous namespace)::vectorized_layer_norm_kernel(int, float, c10::BFloat16 const*, c10::BFloat16 const*, c10::BFloat16 const*, float*, float*, c10::BFloat16*)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 49, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 228.90100000003076, + "self_cuda_time_us": 228.90100000003076 + }, + { + "op": "aten::silu", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ] + ], + "count": 24, + "cpu_time_us": 376.8919999999998, + "self_cpu_time_us": 246.1010000000606, + "cuda_time_us": 209.22299999992538, + "self_cuda_time_us": 209.22299999992538 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#6}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#6}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 209.22299999992538, + "self_cuda_time_us": 209.22299999992538 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 1024, + 16 + ] + ], + "count": 24, + "cpu_time_us": 735.976000000006, + "self_cpu_time_us": 496.59800000000905, + "cuda_time_us": 208.74600000000282, + "self_cuda_time_us": 208.74600000000282 + }, + { + "op": "aten::silu", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ] + ], + "count": 32, + "cpu_time_us": 425.71500000001106, + "self_cpu_time_us": 269.4019999999, + "cuda_time_us": 206.31400000001304, + "self_cuda_time_us": 206.31400000001304 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#6}::operator()() const::{lambda(c10::BFloat16)#1}, std::array, false>(int, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#6}::operator()() const::{lambda(c10::BFloat16)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 32, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 206.31400000001304, + "self_cuda_time_us": 206.31400000001304 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 56, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 199.08199999990757, + "self_cuda_time_us": 199.08199999990757 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [ + 1, + 32, + 8, + 64, + 64 + ] + ], + "count": 48, + "cpu_time_us": 602.0589999999356, + "self_cpu_time_us": 376.26799999996, + "cuda_time_us": 198.40200000014738, + "self_cuda_time_us": 198.40200000014738 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 16 + ], + [ + 16, + 2560 + ] + ], + "count": 40, + "cpu_time_us": 615.3569999998872, + "self_cpu_time_us": 434.8779999999824, + "cuda_time_us": 196.7719999998517, + "self_cuda_time_us": 196.7719999998517 + }, + { + "op": "Memcpy DtoD (Device -> Device)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 82, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 193.9570000000167, + "self_cuda_time_us": 193.9570000000167 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::exp_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::exp_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 120, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 186.69799999988027, + "self_cuda_time_us": 186.69799999988027 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::rsqrt_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::rsqrt_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 153, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 180.55999999998312, + "self_cuda_time_us": 180.55999999998312 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [ + 14592, + 128 + ] + ], + "count": 24, + "cpu_time_us": 303.76900000002934, + "self_cpu_time_us": 178.26100000008591, + "cuda_time_us": 180.20199999997567, + "self_cuda_time_us": 180.20199999997567 + }, + { + "op": "void at::native::unrolled_elementwise_kernel >, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1> >(int, at::native::BinaryFunctor >, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 180.20199999997567, + "self_cuda_time_us": 180.20199999997567 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 1200, + 1024 + ], + [] + ], + "count": 49, + "cpu_time_us": 465.97099999999773, + "self_cpu_time_us": 232.58899999997448, + "cuda_time_us": 175.4969999999994, + "self_cuda_time_us": 175.4969999999994 + }, + { + "op": "void cutlass::Kernel2(cutlass_80_wmma_tensorop_bf16_s161616gemm_bf16_32x32_64x1_tn_align8::Params)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 48, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 172.93799999993644, + "self_cuda_time_us": 172.93799999993644 + }, + { + "op": "aten::gelu", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [] + ], + "count": 24, + "cpu_time_us": 340.953000000005, + "self_cpu_time_us": 217.93399999998655, + "cuda_time_us": 164.87299999999595, + "self_cuda_time_us": 164.87299999999595 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::GeluCUDAKernelImpl(at::TensorIteratorBase&, at::native::GeluType)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array, false>(int, at::native::GeluCUDAKernelImpl(at::TensorIteratorBase&, at::native::GeluType)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 164.87299999999595, + "self_cuda_time_us": 164.87299999999595 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 32, + "cpu_time_us": 337.4529999999504, + "self_cpu_time_us": 176.4140000000043, + "cuda_time_us": 162.99300000001676, + "self_cuda_time_us": 162.99300000001676 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560 + ], + [ + 2560 + ], + [] + ], + "count": 65, + "cpu_time_us": 568.9090000000506, + "self_cpu_time_us": 277.09300000003714, + "cuda_time_us": 160.52500000000146, + "self_cuda_time_us": 160.52500000000146 + }, + { + "op": "cua.readout", + "device_type": "DeviceType.CUDA", + "is_user_annotation": true, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 148.0789999999979, + "self_cuda_time_us": 148.0789999999979 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 40, + "cpu_time_us": 496.5790000000561, + "self_cpu_time_us": 320.46600000008766, + "cuda_time_us": 144.55799999999, + "self_cuda_time_us": 144.55799999999 + }, + { + "op": "aten::neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 32 + ] + ], + "count": 48, + "cpu_time_us": 580.4740000000093, + "self_cpu_time_us": 363.8250000000262, + "cuda_time_us": 140.65399999999863, + "self_cuda_time_us": 140.65399999999863 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 48, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 140.65399999999863, + "self_cuda_time_us": 140.65399999999863 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [ + 14592, + 1 + ] + ], + "count": 24, + "cpu_time_us": 294.6540000000241, + "self_cpu_time_us": 191.14599999993516, + "cuda_time_us": 135.24999999995634, + "self_cuda_time_us": 135.24999999995634 + }, + { + "op": "aten::silu", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ] + ], + "count": 24, + "cpu_time_us": 350.6930000000575, + "self_cpu_time_us": 221.53800000007323, + "cuda_time_us": 133.29600000004575, + "self_cuda_time_us": 133.29600000004575 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 133.29600000004575, + "self_cuda_time_us": 133.29600000004575 + }, + { + "op": "aten::pow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [] + ], + "count": 24, + "cpu_time_us": 499.4279999999417, + "self_cpu_time_us": 348.6809999998077, + "cuda_time_us": 131.98199999998906, + "self_cuda_time_us": 131.98199999998906 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456 + ], + [ + 1, + 32, + 456 + ], + [] + ], + "count": 72, + "cpu_time_us": 615.2590000000855, + "self_cpu_time_us": 322.9800000000032, + "cuda_time_us": 131.50900000004913, + "self_cuda_time_us": 131.50900000004913 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [] + ], + "count": 24, + "cpu_time_us": 298.4540000000852, + "self_cpu_time_us": 190.6890000000276, + "cuda_time_us": 125.74400000001333, + "self_cuda_time_us": 125.74400000001333 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [ + 1, + 456, + 8192 + ], + [] + ], + "count": 8, + "cpu_time_us": 91.61400000004505, + "self_cpu_time_us": 55.17900000003283, + "cuda_time_us": 125.23500000000058, + "self_cuda_time_us": 125.23500000000058 + }, + { + "op": "aten::mean", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 493.51500000001397, + "self_cpu_time_us": 364.9459999999526, + "cuda_time_us": 124.36700000002747, + "self_cuda_time_us": 124.36700000002747 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [ + 1, + 456, + 32, + 128 + ], + [] + ], + "count": 24, + "cpu_time_us": 262.43200000001525, + "self_cpu_time_us": 140.7429999999149, + "cuda_time_us": 122.22300000002724, + "self_cuda_time_us": 122.22300000002724 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::bfloat16_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda(float)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::bfloat16_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda(float)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 122.22300000002724, + "self_cuda_time_us": 122.22300000002724 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 128 + ], + [ + 14592, + 128 + ] + ], + "count": 24, + "cpu_time_us": 320.8670000000275, + "self_cpu_time_us": 198.38799999999173, + "cuda_time_us": 121.64899999993213, + "self_cuda_time_us": 121.64899999993213 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 16, + 1024 + ] + ], + "count": 24, + "cpu_time_us": 356.22999999999956, + "self_cpu_time_us": 260.66699999999764, + "cuda_time_us": 116.40399999999136, + "self_cuda_time_us": 116.40399999999136 + }, + { + "op": "Memset (Device)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 196, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 113.80399999988731, + "self_cuda_time_us": 113.80399999988731 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "count": 24, + "cpu_time_us": 177.31299999990733, + "self_cpu_time_us": 80.42099999984202, + "cuda_time_us": 108.97900000006484, + "self_cuda_time_us": 108.97900000006484 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 16 + ], + [ + 16, + 8192 + ] + ], + "count": 8, + "cpu_time_us": 201.32599999992817, + "self_cpu_time_us": 154.85099999986414, + "cuda_time_us": 100.72500000002037, + "self_cuda_time_us": 100.72500000002037 + }, + { + "op": "void cutlass::Kernel2(cutlass_80_simt_sgemm_256x128_8x4_tn_align1::Params)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 100.72500000002037, + "self_cuda_time_us": 100.72500000002037 + }, + { + "op": "aten::masked_fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [ + 64, + 64 + ], + [] + ], + "count": 24, + "cpu_time_us": 427.76699999995617, + "self_cpu_time_us": 240.90799999991577, + "cuda_time_us": 100.07999999989988, + "self_cuda_time_us": 100.07999999989988 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::(anonymous namespace)::masked_fill_kernel(at::TensorIterator&, c10::Scalar const&)::{lambda()#1}::operator()() const::{lambda()#7}::operator()() const::{lambda(float, bool)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::(anonymous namespace)::masked_fill_kernel(at::TensorIterator&, c10::Scalar const&)::{lambda()#1}::operator()() const::{lambda()#7}::operator()() const::{lambda(float, bool)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 100.07999999989988, + "self_cuda_time_us": 100.07999999989988 + }, + { + "op": "aten::arange", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [ + 0 + ] + ], + "count": 107, + "cpu_time_us": 1324.8919999999343, + "self_cpu_time_us": 521.9169999998776, + "cuda_time_us": 98.58299999991141, + "self_cuda_time_us": 98.58299999991141 + }, + { + "op": "void (anonymous namespace)::elementwise_kernel_with_index(int, at::native::arange_cuda_out(c10::Scalar const&, c10::Scalar const&, c10::Scalar const&, at::Tensor&)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}, function_traits::result_type*)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 106, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 98.58299999991141, + "self_cuda_time_us": 98.58299999991141 + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096 + ], + [ + 300, + 4096 + ], + [ + 4096, + 4096 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 24.624000000003434, + "self_cpu_time_us": 16.046000000002095, + "cuda_time_us": 93.59000000000378, + "self_cuda_time_us": 93.59000000000378 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [] + ], + "count": 24, + "cpu_time_us": 291.89699999999357, + "self_cpu_time_us": 190.26699999999983, + "cuda_time_us": 91.8269999999975, + "self_cuda_time_us": 91.8269999999975 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 1 + ], + [ + 1, + 32, + 8, + 1, + 64 + ], + [] + ], + "count": 24, + "cpu_time_us": 381.429999999993, + "self_cpu_time_us": 261.8319999999221, + "cuda_time_us": 90.99599999999919, + "self_cuda_time_us": 90.99599999999919 + }, + { + "op": "void cublasLt::splitKreduce_kernel<32, 16, int, __nv_bfloat16, __nv_bfloat16, float, __nv_bfloat16, false, __nv_bfloat16, __nv_bfloat16, __nv_bfloat16, true, false, false, false>(cublasLt::cublasSplitKParams, __nv_bfloat16 const*, __nv_bfloat16 const*, __nv_bfloat16*, __nv_bfloat16*, float const*, float const*, __nv_bfloat16 const*, __nv_bfloat16 const*, __nv_bfloat16*, void*, long, float*, int*, float*, float*, float const*, float const*, float const*, float const*, float const*)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 48, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 84.43600000007427, + "self_cuda_time_us": 84.43600000007427 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 26, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 82.20099999999366, + "self_cuda_time_us": 82.20099999999366 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [ + 1, + 32, + 8, + 64, + 64 + ], + [] + ], + "count": 24, + "cpu_time_us": 501.0800000000454, + "self_cpu_time_us": 90.44300000007206, + "cuda_time_us": 81.40099999999074, + "self_cuda_time_us": 81.40099999999074 + }, + { + "op": "aten::rsqrt", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1 + ] + ], + "count": 65, + "cpu_time_us": 731.7389999999941, + "self_cpu_time_us": 447.42999999992753, + "cuda_time_us": 80.56899999992311, + "self_cuda_time_us": 80.56899999992311 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [] + ], + "count": 48, + "cpu_time_us": 429.12799999997515, + "self_cpu_time_us": 201.42699999982142, + "cuda_time_us": 80.18199999991339, + "self_cuda_time_us": 80.18199999991339 + }, + { + "op": "aten::exp", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ] + ], + "count": 72, + "cpu_time_us": 795.2769999999728, + "self_cpu_time_us": 491.5199999999895, + "cuda_time_us": 79.57599999986269, + "self_cuda_time_us": 79.57599999986269 + }, + { + "op": "Memcpy DtoH (Device -> Pageable)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 77, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 79.13100000000122, + "self_cuda_time_us": 79.13100000000122 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [ + 1 + ], + [] + ], + "count": 78, + "cpu_time_us": 1341.733999999964, + "self_cpu_time_us": 361.7919999999758, + "cuda_time_us": 77.97800000001371, + "self_cuda_time_us": 77.97800000001371 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1 + ], + [], + [] + ], + "count": 65, + "cpu_time_us": 789.8220000000147, + "self_cpu_time_us": 516.5269999999873, + "cuda_time_us": 77.30799999982264, + "self_cuda_time_us": 77.30799999982264 + }, + { + "op": "aten::exp", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ] + ], + "count": 24, + "cpu_time_us": 295.4619999999777, + "self_cpu_time_us": 190.08799999993062, + "cuda_time_us": 77.30199999995966, + "self_cuda_time_us": 77.30199999995966 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [] + ], + "count": 8, + "cpu_time_us": 103.67799999995623, + "self_cpu_time_us": 66.29099999996834, + "cuda_time_us": 76.7270000000135, + "self_cuda_time_us": 76.7270000000135 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [ + 32 + ], + [] + ], + "count": 24, + "cpu_time_us": 374.2820000000356, + "self_cpu_time_us": 258.74700000002485, + "cuda_time_us": 76.40899999999237, + "self_cuda_time_us": 76.40899999999237 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 4096 + ], + [ + 4096, + 16 + ] + ], + "count": 8, + "cpu_time_us": 209.5629999999801, + "self_cpu_time_us": 134.77599999998347, + "cuda_time_us": 74.16800000000512, + "self_cuda_time_us": 74.16800000000512 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560 + ], + [], + [] + ], + "count": 65, + "cpu_time_us": 737.5530000001527, + "self_cpu_time_us": 471.67600000012317, + "cuda_time_us": 72.08599999993748, + "self_cuda_time_us": 72.08599999993748 + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560 + ], + [ + 300, + 4096 + ], + [ + 4096, + 2560 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 23.169000000001688, + "self_cpu_time_us": 15.173000000002503, + "cuda_time_us": 65.43299999999726, + "self_cuda_time_us": 65.43299999999726 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::sigmoid_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array, false>(int, at::native::sigmoid_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 32, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 64.66100000011647, + "self_cuda_time_us": 64.66100000011647 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 4 + ], + [ + 1, + 8192, + 4 + ], + [] + ], + "count": 24, + "cpu_time_us": 311.8920000000144, + "self_cpu_time_us": 187.04300000001967, + "cuda_time_us": 61.43200000001525, + "self_cuda_time_us": 61.43200000001525 + }, + { + "op": "void pytorch_flash::flash_fwd_splitkv_combine_kernel >, 4, 1, true>(pytorch_flash::Flash_fwd_params)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 59.83299999999872, + "self_cuda_time_us": 59.83299999999872 + }, + { + "op": "aten::cumsum", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 401.1610000000728, + "self_cpu_time_us": 272.68400000010297, + "cuda_time_us": 59.351999999977124, + "self_cuda_time_us": 59.351999999977124 + }, + { + "op": "void at::native::tensor_kernel_scan_innermost_dim >(float*, float const*, unsigned int, unsigned int, unsigned int, float, std::plus)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 59.351999999977124, + "self_cuda_time_us": 59.351999999977124 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [ + 1, + 456, + 1024 + ], + [] + ], + "count": 16, + "cpu_time_us": 176.71699999998964, + "self_cpu_time_us": 105.85599999999977, + "cuda_time_us": 55.7379999999539, + "self_cuda_time_us": 55.7379999999539 + }, + { + "op": "aten::rsqrt", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 1 + ] + ], + "count": 48, + "cpu_time_us": 517.8670000000639, + "self_cpu_time_us": 316.39400000017486, + "cuda_time_us": 53.66100000001461, + "self_cuda_time_us": 53.66100000001461 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 1 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 571.4909999999145, + "self_cpu_time_us": 373.4019999999, + "cuda_time_us": 51.963999999919906, + "self_cuda_time_us": 51.963999999919906 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [ + 1, + 456, + 32 + ], + [] + ], + "count": 24, + "cpu_time_us": 202.0879999999379, + "self_cpu_time_us": 98.49399999992602, + "cuda_time_us": 51.25500000001921, + "self_cuda_time_us": 51.25500000001921 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [ + 1, + 456, + 8192 + ], + [] + ], + "count": 8, + "cpu_time_us": 69.4840000000695, + "self_cpu_time_us": 34.94100000009348, + "cuda_time_us": 49.21000000003551, + "self_cuda_time_us": 49.21000000003551 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [ + 1, + 32, + 128, + 128 + ], + [] + ], + "count": 24, + "cpu_time_us": 477.0920000000624, + "self_cpu_time_us": 96.88300000005984, + "cuda_time_us": 48.66400000001886, + "self_cuda_time_us": 48.66400000001886 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 1, + 456, + 4096 + ], + [] + ], + "count": 8, + "cpu_time_us": 83.34600000001956, + "self_cpu_time_us": 40.029000000067754, + "cuda_time_us": 47.8349999999773, + "self_cuda_time_us": 47.8349999999773 + }, + { + "op": "aten::triu", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 64, + 64 + ], + [] + ], + "count": 24, + "cpu_time_us": 377.87199999999575, + "self_cpu_time_us": 257.0589999999647, + "cuda_time_us": 46.5869999999486, + "self_cuda_time_us": 46.5869999999486 + }, + { + "op": "void at::native::triu_tril_kernel(at::cuda::detail::TensorInfo, at::cuda::detail::TensorInfo, long, long, int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 46.5869999999486, + "self_cuda_time_us": 46.5869999999486 + }, + { + "op": "aten::softplus", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 340.97199999997247, + "self_cpu_time_us": 222.82799999988492, + "cuda_time_us": 46.52400000009948, + "self_cuda_time_us": 46.52400000009948 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::softplus_kernel(at::TensorIteratorBase&, c10::Scalar const&, c10::Scalar const&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::(anonymous namespace)::softplus_kernel(at::TensorIteratorBase&, c10::Scalar const&, c10::Scalar const&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 46.52400000009948, + "self_cuda_time_us": 46.52400000009948 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 64 + ], + [ + 1, + 1, + 456, + 64 + ] + ], + "count": 16, + "cpu_time_us": 225.9019999999582, + "self_cpu_time_us": 147.00199999997858, + "cuda_time_us": 46.36499999999069, + "self_cuda_time_us": 46.36499999999069 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [ + 256 + ] + ], + "count": 8, + "cpu_time_us": 89.61600000002363, + "self_cpu_time_us": 57.51599999998871, + "cuda_time_us": 46.30099999997765, + "self_cuda_time_us": 46.30099999997765 + }, + { + "op": "void cudnn::engines_precompiled::nchwToNhwcKernel<__nv_bfloat16, __nv_bfloat16, float, false, true, (cudnnKernelDataType_t)0>(cudnn::engines_precompiled::nchw2nhwc_params_t, __nv_bfloat16 const*, __nv_bfloat16*)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 45.788000000004104, + "self_cuda_time_us": 45.788000000004104 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [ + 1, + 456, + 16, + 1 + ] + ], + "count": 8, + "cpu_time_us": 94.89599999999336, + "self_cpu_time_us": 60.838000000003376, + "cuda_time_us": 45.08400000001711, + "self_cuda_time_us": 45.08400000001711 + }, + { + "op": "aten::pow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 8, + "cpu_time_us": 197.13700000000244, + "self_cpu_time_us": 156.08799999998882, + "cuda_time_us": 44.059000000022934, + "self_cuda_time_us": 44.059000000022934 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [] + ], + "count": 48, + "cpu_time_us": 331.59599999999045, + "self_cpu_time_us": 147.0729999999894, + "cuda_time_us": 43.13400000008551, + "self_cuda_time_us": 43.13400000008551 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 17, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 40.795999999983906, + "self_cuda_time_us": 40.795999999983906 + }, + { + "op": "aten::exp", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8 + ] + ], + "count": 24, + "cpu_time_us": 297.38099999996484, + "self_cpu_time_us": 188.30100000002858, + "cuda_time_us": 39.22699999999895, + "self_cuda_time_us": 39.22699999999895 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::exp_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::exp_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 39.22699999999895, + "self_cuda_time_us": 39.22699999999895 + }, + { + "op": "aten::mean", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 125.61199999997916, + "self_cpu_time_us": 89.25299999998242, + "cuda_time_us": 38.32900000002701, + "self_cuda_time_us": 38.32900000002701 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ], + [ + 32 + ], + [] + ], + "count": 24, + "cpu_time_us": 235.820999999989, + "self_cpu_time_us": 117.89099999998143, + "cuda_time_us": 38.20400000005611, + "self_cuda_time_us": 38.20400000005611 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ], + [ + 1, + 456, + 32 + ] + ], + "count": 24, + "cpu_time_us": 317.81500000003143, + "self_cpu_time_us": 201.51100000003498, + "cuda_time_us": 36.540999999968335, + "self_cuda_time_us": 36.540999999968335 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 1 + ], + [ + 1, + 32, + 8, + 64 + ], + [] + ], + "count": 24, + "cpu_time_us": 319.7990000000209, + "self_cpu_time_us": 210.54600000010396, + "cuda_time_us": 35.80500000001484, + "self_cuda_time_us": 35.80500000001484 + }, + { + "op": "aten::sigmoid", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ] + ], + "count": 24, + "cpu_time_us": 378.90200000003097, + "self_cpu_time_us": 246.82800000011048, + "cuda_time_us": 35.35300000009738, + "self_cuda_time_us": 35.35300000009738 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [ + 1, + 456, + 4, + 256 + ], + [] + ], + "count": 16, + "cpu_time_us": 137.5920000000042, + "self_cpu_time_us": 65.09799999998359, + "cuda_time_us": 34.0460000000312, + "self_cuda_time_us": 34.0460000000312 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#9}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#9}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 31.581999999965774, + "self_cuda_time_us": 31.581999999965774 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 64 + ], + [ + 1, + 1, + 456, + 64 + ] + ], + "count": 16, + "cpu_time_us": 181.30599999999686, + "self_cpu_time_us": 116.03000000004249, + "cuda_time_us": 31.06799999998475, + "self_cuda_time_us": 31.06799999998475 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 256 + ], + [ + 256 + ], + [] + ], + "count": 16, + "cpu_time_us": 137.33299999996962, + "self_cpu_time_us": 66.4359999999433, + "cuda_time_us": 31.00199999997858, + "self_cuda_time_us": 31.00199999997858 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 1, + 456, + 4096 + ] + ], + "count": 8, + "cpu_time_us": 104.29400000000896, + "self_cpu_time_us": 67.72400000000198, + "cuda_time_us": 30.586999999999534, + "self_cuda_time_us": 30.586999999999534 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [] + ], + "count": 16, + "cpu_time_us": 199.92800000001444, + "self_cpu_time_us": 128.56800000004296, + "cuda_time_us": 30.20299999997951, + "self_cuda_time_us": 30.20299999997951 + }, + { + "op": "aten::exp", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ] + ], + "count": 24, + "cpu_time_us": 341.94899999999325, + "self_cpu_time_us": 226.38799999995535, + "cuda_time_us": 29.820000000057917, + "self_cuda_time_us": 29.820000000057917 + }, + { + "op": "aten::sigmoid", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ] + ], + "count": 8, + "cpu_time_us": 111.13100000002305, + "self_cpu_time_us": 71.45100000007369, + "cuda_time_us": 29.308000000019092, + "self_cuda_time_us": 29.308000000019092 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [ + 1 + ], + [] + ], + "count": 24, + "cpu_time_us": 347.4999999999927, + "self_cpu_time_us": 227.54499999999462, + "cuda_time_us": 27.57900000000882, + "self_cuda_time_us": 27.57900000000882 + }, + { + "op": "void at::native::unrolled_elementwise_kernel, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast>(int, at::native::CUDAFunctor_add, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 27.57900000000882, + "self_cuda_time_us": 27.57900000000882 + }, + { + "op": "aten::rsqrt", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 1 + ] + ], + "count": 24, + "cpu_time_us": 316.82300000000396, + "self_cpu_time_us": 199.91700000004494, + "cuda_time_us": 27.323000000047614, + "self_cuda_time_us": 27.323000000047614 + }, + { + "op": "cudaStreamIsCapturing", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 88, + "cpu_time_us": 47.579000000016094, + "self_cpu_time_us": 47.579000000016094, + "cuda_time_us": 27.228999999992084, + "self_cuda_time_us": 27.228999999992084 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 1 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 350.02599999992526, + "self_cpu_time_us": 240.88399999994726, + "cuda_time_us": 26.8449999998993, + "self_cuda_time_us": 26.8449999998993 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [ + 1, + 456, + 1024 + ], + [] + ], + "count": 16, + "cpu_time_us": 135.07000000000698, + "self_cpu_time_us": 69.0959999999759, + "cuda_time_us": 26.491000000038184, + "self_cuda_time_us": 26.491000000038184 + }, + { + "op": "aten::neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ] + ], + "count": 24, + "cpu_time_us": 320.3859999999695, + "self_cpu_time_us": 200.5319999999483, + "cuda_time_us": 25.597999999983585, + "self_cuda_time_us": 25.597999999983585 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 25.597999999983585, + "self_cuda_time_us": 25.597999999983585 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 64, + 64 + ], + [] + ], + "count": 24, + "cpu_time_us": 232.41800000009243, + "self_cpu_time_us": 124.43900000002759, + "cuda_time_us": 22.972999999932654, + "self_cuda_time_us": 22.972999999932654 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::FillFunctor, std::array, false>(int, at::native::FillFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 22.972999999932654, + "self_cuda_time_us": 22.972999999932654 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [ + 256 + ] + ], + "count": 8, + "cpu_time_us": 87.8350000000064, + "self_cpu_time_us": 53.63400000004913, + "cuda_time_us": 22.489999999990687, + "self_cuda_time_us": 22.489999999990687 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 4 + ], + [] + ], + "count": 24, + "cpu_time_us": 277.76999999997497, + "self_cpu_time_us": 146.97799999992276, + "cuda_time_us": 22.363999999950465, + "self_cuda_time_us": 22.363999999950465 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::FillFunctor, std::array, false>(int, at::native::FillFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 22.363999999950465, + "self_cuda_time_us": 22.363999999950465 + }, + { + "op": "Memcpy DtoH (Device -> Pinned)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 21, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 21.66199999998571, + "self_cuda_time_us": 21.66199999998571 + }, + { + "op": "aten::mean", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 117.5850000000064, + "self_cpu_time_us": 83.02700000001641, + "cuda_time_us": 21.59700000003795, + "self_cuda_time_us": 21.59700000003795 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [ + 1, + 456, + 4, + 1 + ] + ], + "count": 8, + "cpu_time_us": 89.93500000004133, + "self_cpu_time_us": 56.05800000006275, + "cuda_time_us": 21.406000000002678, + "self_cuda_time_us": 21.406000000002678 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 64 + ], + [ + 1, + 16, + 456, + 64 + ], + [] + ], + "count": 8, + "cpu_time_us": 106.51399999998102, + "self_cpu_time_us": 69.82599999995728, + "cuda_time_us": 20.413999999975204, + "self_cuda_time_us": 20.413999999975204 + }, + { + "op": "aten::_local_scalar_dense", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [] + ], + "count": 19, + "cpu_time_us": 270.3729999999923, + "self_cpu_time_us": 113.15600000001723, + "cuda_time_us": 18.653999999991356, + "self_cuda_time_us": 18.653999999991356 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4, + 1024 + ], + [ + 1200, + 4, + 1 + ] + ], + "count": 1, + "cpu_time_us": 18.31999999999971, + "self_cpu_time_us": 12.015999999999622, + "cuda_time_us": 17.822000000000116, + "self_cuda_time_us": 17.822000000000116 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 17.822000000000116, + "self_cuda_time_us": 17.822000000000116 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 4096, + 16 + ] + ], + "count": 2, + "cpu_time_us": 43.45599999999831, + "self_cpu_time_us": 26.70300000000134, + "cuda_time_us": 17.6929999999993, + "self_cuda_time_us": 17.6929999999993 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 256 + ], + [], + [] + ], + "count": 16, + "cpu_time_us": 172.91800000000512, + "self_cpu_time_us": 109.70999999996275, + "cuda_time_us": 17.0839999999298, + "self_cuda_time_us": 17.0839999999298 + }, + { + "op": "aten::neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 32 + ] + ], + "count": 8, + "cpu_time_us": 128.49400000000605, + "self_cpu_time_us": 87.88999999998487, + "cuda_time_us": 16.926999999966938, + "self_cuda_time_us": 16.926999999966938 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 64 + ], + [ + 1, + 4, + 456, + 64 + ], + [] + ], + "count": 8, + "cpu_time_us": 89.06599999996251, + "self_cpu_time_us": 57.50399999998626, + "cuda_time_us": 15.903000000005704, + "self_cuda_time_us": 15.903000000005704 + }, + { + "op": "aten::masked_scatter_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 2560 + ], + [ + 300, + 2560 + ] + ], + "count": 1, + "cpu_time_us": 95.32500000000437, + "self_cpu_time_us": 40.05200000000332, + "cuda_time_us": 18.07900000000518, + "self_cuda_time_us": 15.039000000004307 + }, + { + "op": "aten::pow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [] + ], + "count": 8, + "cpu_time_us": 119.09400000001187, + "self_cpu_time_us": 79.7790000000823, + "cuda_time_us": 14.975999999980559, + "self_cuda_time_us": 14.975999999980559 + }, + { + "op": "aten::nonzero", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ] + ], + "count": 3, + "cpu_time_us": 211.9499999999898, + "self_cpu_time_us": 100.53899999999703, + "cuda_time_us": 14.781999999984691, + "self_cuda_time_us": 14.781999999984691 + }, + { + "op": "aten::neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 32 + ] + ], + "count": 8, + "cpu_time_us": 96.44200000002456, + "self_cpu_time_us": 60.576000000030035, + "cuda_time_us": 14.654999999998836, + "self_cuda_time_us": 14.654999999998836 + }, + { + "op": "aten::cumsum", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [] + ], + "count": 6, + "cpu_time_us": 270.9419999999991, + "self_cpu_time_us": 160.49399999999514, + "cuda_time_us": 15.516999999996187, + "self_cuda_time_us": 14.140999999995984 + }, + { + "op": "aten::sum", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4, + 1024 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 22.76599999999962, + "self_cpu_time_us": 16.454000000001543, + "cuda_time_us": 13.43800000000192, + "self_cuda_time_us": 13.43800000000192 + }, + { + "op": "void at::native::reduce_kernel<128, 4, at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(float, float)#1}>, unsigned int, float, 4, 4> >(at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(float, float)#1}>, unsigned int, float, 4, 4>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 13.43800000000192, + "self_cuda_time_us": 13.43800000000192 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 300, + 4096 + ], + [] + ], + "count": 3, + "cpu_time_us": 26.934000000001106, + "self_cpu_time_us": 13.173000000009779, + "cuda_time_us": 11.293000000005122, + "self_cuda_time_us": 11.293000000005122 + }, + { + "op": "void at::native::unrolled_elementwise_kernel, 4, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1> >(int, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}, std::array, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 5, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 10.718000000004395, + "self_cuda_time_us": 10.718000000004395 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [ + 1, + 456 + ], + [] + ], + "count": 7, + "cpu_time_us": 436.9740000000056, + "self_cpu_time_us": 56.07400000001144, + "cuda_time_us": 10.3340000000062, + "self_cuda_time_us": 10.3340000000062 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::CUDAFunctorOnSelf_add, std::array, false>(int, at::native::CUDAFunctorOnSelf_add, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 9, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 10.239999999990687, + "self_cuda_time_us": 10.239999999990687 + }, + { + "op": "void at::native::vectorized_gather_kernel<16, long>(char*, char*, long*, int, long, long, long, long, bool)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 9.94999999999709, + "self_cuda_time_us": 9.94999999999709 + }, + { + "op": "aten::rsqrt", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 1 + ] + ], + "count": 8, + "cpu_time_us": 84.68900000001304, + "self_cpu_time_us": 49.83200000003853, + "cuda_time_us": 9.823999999993248, + "self_cuda_time_us": 9.823999999993248 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 1 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 100.42900000001828, + "self_cpu_time_us": 59.632000000055996, + "cuda_time_us": 9.313000000009197, + "self_cuda_time_us": 9.313000000009197 + }, + { + "op": "aten::rsqrt", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 1 + ] + ], + "count": 8, + "cpu_time_us": 90.88900000005378, + "self_cpu_time_us": 56.50300000004063, + "cuda_time_us": 9.18300000000454, + "self_cuda_time_us": 9.18300000000454 + }, + { + "op": "aten::gather", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [ + 1200 + ], + [], + [ + 1200 + ] + ], + "count": 3, + "cpu_time_us": 56.03100000000268, + "self_cpu_time_us": 33.42300000000614, + "cuda_time_us": 9.18199999999706, + "self_cuda_time_us": 9.18199999999706 + }, + { + "op": "void at::native::_scatter_gather_elementwise_kernel<128, 8, at::native::_cuda_scatter_gather_internal_kernel, long>::operator()(at::TensorIterator&, long, long, long, at::native::TensorAssign const&)::{lambda(int)#1}>(int, at::native::_cuda_scatter_gather_internal_kernel, long>::operator()(at::TensorIterator&, long, long, long, at::native::TensorAssign const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 3, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 9.18199999999706, + "self_cuda_time_us": 9.18199999999706 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 1 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 100.70599999999104, + "self_cpu_time_us": 68.25099999997474, + "cuda_time_us": 8.959999999991851, + "self_cuda_time_us": 8.959999999991851 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::BUnaryFunctor, std::array, false>(int, at::native::BUnaryFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 5, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 8.927999999996246, + "self_cuda_time_us": 8.927999999996246 + }, + { + "op": "void at::native::unrolled_elementwise_kernel, 4, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1> >(int, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#11}::operator()() const::{lambda(bool)#1}, std::array, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 4, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 8.799999999995634, + "self_cuda_time_us": 8.799999999995634 + }, + { + "op": "void at::native::reduce_kernel<512, 1, at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(long, long)#1}>, unsigned int, long, 4, 4> >(at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(long, long)#1}>, unsigned int, long, 4, 4>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 4, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 8.640000000006694, + "self_cuda_time_us": 8.640000000006694 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ], + [] + ], + "count": 4, + "cpu_time_us": 41.34600000000137, + "self_cpu_time_us": 20.866000000005442, + "cuda_time_us": 8.54200000000128, + "self_cuda_time_us": 8.54200000000128 + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceScanKernel >::Policy1000, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, long*, at_cuda_detail::cub::ScanTileState, at::cuda::cub::(anonymous namespace)::SumOp, at_cuda_detail::cub::detail::InputValue, unsigned int, long, false, long>(thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, long*, at_cuda_detail::cub::ScanTileState, int, at::cuda::cub::(anonymous namespace)::SumOp, at_cuda_detail::cub::detail::InputValue, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 8.447000000000116, + "self_cuda_time_us": 8.447000000000116 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [ + 456 + ], + [] + ], + "count": 4, + "cpu_time_us": 50.16800000000512, + "self_cpu_time_us": 19.54100000001199, + "cuda_time_us": 8.319999999992433, + "self_cuda_time_us": 8.319999999992433 + }, + { + "op": "aten::index", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [] + ], + "count": 2, + "cpu_time_us": 215.9059999999954, + "self_cpu_time_us": 47.263000000006286, + "cuda_time_us": 17.15099999998347, + "self_cuda_time_us": 7.19999999999709 + }, + { + "op": "void at::native::index_elementwise_kernel<128, 4, at::native::gpu_index_kernel >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_kernel_impl >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1}>(long, at::native::gpu_index_kernel >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_kernel_impl >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 7.19999999999709, + "self_cuda_time_us": 7.19999999999709 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::AUnaryFunctor >, std::array, false>(int, at::native::AUnaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 6, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 7.135000000002037, + "self_cuda_time_us": 7.135000000002037 + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceScanKernel >::Policy1000, long const*, long*, at_cuda_detail::cub::ScanTileState, std::plus, at_cuda_detail::cub::NullType, unsigned int, long, false, at_cuda_detail::cub::NullType>(long const*, long*, at_cuda_detail::cub::ScanTileState, int, std::plus, at_cuda_detail::cub::NullType, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 5, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 7.100000000002183, + "self_cuda_time_us": 7.100000000002183 + }, + { + "op": "aten::gather", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2304, + 1024 + ], + [], + [ + 4800, + 1024 + ], + [], + [ + 4800, + 1024 + ] + ], + "count": 1, + "cpu_time_us": 19.72599999999875, + "self_cpu_time_us": 12.369999999998981, + "cuda_time_us": 7.070999999999913, + "self_cuda_time_us": 7.070999999999913 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 300, + 4096 + ], + [] + ], + "count": 1, + "cpu_time_us": 10.99699999999575, + "self_cpu_time_us": 6.737999999990279, + "cuda_time_us": 6.878999999993539, + "self_cuda_time_us": 6.878999999993539 + }, + { + "op": "aten::sum", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "count": 3, + "cpu_time_us": 137.87500000000728, + "self_cpu_time_us": 56.57799999999406, + "cuda_time_us": 13.023000000008324, + "self_cuda_time_us": 6.496000000006461 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 4, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 6.141999999999825, + "self_cuda_time_us": 6.141999999999825 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::AUnaryFunctor >, std::array, false>(int, at::native::AUnaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 5, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 6.07999999999447, + "self_cuda_time_us": 6.07999999999447 + }, + { + "op": "aten::floor_divide", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [] + ], + "count": 3, + "cpu_time_us": 59.25699999999779, + "self_cpu_time_us": 27.155999999991764, + "cuda_time_us": 5.952000000001135, + "self_cuda_time_us": 5.952000000001135 + }, + { + "op": "aten::repeat_interleave", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 4, + "cpu_time_us": 647.6330000000016, + "self_cpu_time_us": 89.3310000000165, + "cuda_time_us": 32.219999999997526, + "self_cuda_time_us": 5.855000000003201 + }, + { + "op": "void compute_cuda_kernel(long const*, long const*, long*, long, long)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 4, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 5.855000000003201, + "self_cuda_time_us": 5.855000000003201 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [] + ], + "count": 5, + "cpu_time_us": 59.61699999999837, + "self_cpu_time_us": 37.94699999999648, + "cuda_time_us": 5.85399999999936, + "self_cuda_time_us": 5.85399999999936 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1 + ], + [ + 2 + ], + [] + ], + "count": 2, + "cpu_time_us": 24.524999999997817, + "self_cpu_time_us": 15.44800000000032, + "cuda_time_us": 5.792000000001281, + "self_cuda_time_us": 5.792000000001281 + }, + { + "op": "aten::div", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ] + ], + "count": 2, + "cpu_time_us": 32.87800000000061, + "self_cpu_time_us": 21.39100000000326, + "cuda_time_us": 5.758999999998196, + "self_cuda_time_us": 5.758999999998196 + }, + { + "op": "void at::native::unrolled_elementwise_kernel >, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1> >(int, at::native::BinaryFunctor >, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 5.758999999998196, + "self_cuda_time_us": 5.758999999998196 + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceScanInitKernel >(at_cuda_detail::cub::ScanTileState, int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 6, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 5.440999999995256, + "self_cuda_time_us": 5.440999999995256 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [] + ], + "count": 5, + "cpu_time_us": 65.91799999999421, + "self_cpu_time_us": 19.80399999999645, + "cuda_time_us": 5.217000000000553, + "self_cuda_time_us": 5.217000000000553 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::(anonymous namespace)::launch_clamp_scalar(at::TensorIteratorBase&, c10::Scalar, c10::Scalar, at::native::detail::ClampLimits)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}, std::array, false>(int, at::native::(anonymous namespace)::launch_clamp_scalar(at::TensorIteratorBase&, c10::Scalar, c10::Scalar, at::native::detail::ClampLimits)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 4, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 5.0240000000012515, + "self_cuda_time_us": 5.0240000000012515 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 16, + 4096 + ] + ], + "count": 1, + "cpu_time_us": 14.870999999999185, + "self_cpu_time_us": 10.841999999996915, + "cuda_time_us": 4.8950000000040745, + "self_cuda_time_us": 4.8950000000040745 + }, + { + "op": "aten::clamp", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [] + ], + "count": 4, + "cpu_time_us": 59.056000000000495, + "self_cpu_time_us": 38.199000000000524, + "cuda_time_us": 4.863000000004831, + "self_cuda_time_us": 4.863000000004831 + }, + { + "op": "void at_cuda_detail::cub::detail::select::DeviceSelectSweepKernel::Policy1000, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::counting_iterator, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, long*, int*, at_cuda_detail::cub::ScanTileState, at_cuda_detail::cub::NullType, at_cuda_detail::cub::NullType, int, at_cuda_detail::cub::detail::select::streaming_context_t, (at_cuda_detail::cub::SelectImpl)0>(thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::counting_iterator, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, long*, int*, at_cuda_detail::cub::ScanTileState, at_cuda_detail::cub::NullType, at_cuda_detail::cub::NullType, int, int, at_cuda_detail::cub::detail::select::streaming_context_t, at_cuda_detail::cub::detail::vsmem_t)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 3, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 4.862999999990279, + "self_cuda_time_us": 4.862999999990279 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::launch_masked_scatter_kernel(at::TensorBase const&, at::TensorBase const&, at::TensorBase const&, at::TensorBase const&)::{lambda()#1}::operator()() const::{lambda()#11}::operator()() const::{lambda(c10::BFloat16, bool, long)#1}, std::array, false>(int, at::native::launch_masked_scatter_kernel(at::TensorBase const&, at::TensorBase const&, at::TensorBase const&, at::TensorBase const&)::{lambda()#1}::operator()() const::{lambda()#11}::operator()() const::{lambda(c10::BFloat16, bool, long)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 4.608000000000175, + "self_cuda_time_us": 4.608000000000175 + }, + { + "op": "aten::ge", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 4, + "cpu_time_us": 81.53499999999622, + "self_cpu_time_us": 56.661999999992986, + "cuda_time_us": 4.543000000001484, + "self_cuda_time_us": 4.543000000001484 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::compare_scalar_kernel(at::TensorIteratorBase&, at::native::(anonymous namespace)::OpType, long)::{lambda(long)#1}, std::array, false>(int, at::native::compare_scalar_kernel(at::TensorIteratorBase&, at::native::(anonymous namespace)::OpType, long)::{lambda(long)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 4, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 4.543000000001484, + "self_cuda_time_us": 4.543000000001484 + }, + { + "op": "aten::add_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024, + 1, + 1, + 1 + ], + [ + 1, + 1024, + 1, + 1, + 1 + ], + [] + ], + "count": 1, + "cpu_time_us": 17.05500000000029, + "self_cpu_time_us": 11.381000000001222, + "cuda_time_us": 4.479000000002998, + "self_cuda_time_us": 4.479000000002998 + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy, unsigned int, 2, 64, 64>(at::native::(anonymous namespace)::OpaqueType<4u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 64, 64>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 4.224000000001979, + "self_cuda_time_us": 4.224000000001979 + }, + { + "op": "void at_cuda_detail::cub::detail::reduce::DeviceReduceSingleTileKernel >::Policy1000, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, int*, unsigned long long, cuda::std::__4::plus, int, int, cuda::std::__4::__identity>(thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, int*, unsigned long long, cuda::std::__4::plus, int, cuda::std::__4::__identity)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 3, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 4.192000000002736, + "self_cuda_time_us": 4.192000000002736 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [ + 300, + 2560 + ], + [] + ], + "count": 1, + "cpu_time_us": 10.895000000004075, + "self_cpu_time_us": 6.469000000004598, + "cuda_time_us": 4.0310000000026776, + "self_cuda_time_us": 4.0310000000026776 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::CUDAFunctor_add, std::array, false>(int, at::native::CUDAFunctor_add, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 3, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3.9989999999997963, + "self_cuda_time_us": 3.9989999999997963 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 16, + 2560 + ] + ], + "count": 1, + "cpu_time_us": 14.44600000000355, + "self_cpu_time_us": 10.40400000000227, + "cuda_time_us": 3.9360000000015134, + "self_cuda_time_us": 3.9360000000015134 + }, + { + "op": "aten::eq", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "count": 3, + "cpu_time_us": 49.408000000003085, + "self_cpu_time_us": 32.57500000001164, + "cuda_time_us": 3.8399999999965075, + "self_cuda_time_us": 3.8399999999965075 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::cos_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::cos_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3.8070000000043365, + "self_cuda_time_us": 3.8070000000043365 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::sin_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::sin_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3.775999999998021, + "self_cuda_time_us": 3.775999999998021 + }, + { + "op": "aten::_index_put_impl_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 456 + ], + [], + [ + 3, + 456 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 95.5, + "self_cpu_time_us": 19.887000000002445, + "cuda_time_us": 8.47899999999936, + "self_cuda_time_us": 3.6480000000010477 + }, + { + "op": "void at::native::index_elementwise_kernel<128, 4, at::native::gpu_index_kernel >(at::TensorIterator&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_put_kernel_impl >(at::TensorIterator&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1}>(long, at::native::gpu_index_kernel >(at::TensorIterator&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_put_kernel_impl >(at::TensorIterator&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3.6480000000010477, + "self_cuda_time_us": 3.6480000000010477 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [] + ], + "count": 1, + "cpu_time_us": 12.051999999996042, + "self_cpu_time_us": 7.9979999999995925, + "cuda_time_us": 3.6160000000018044, + "self_cuda_time_us": 3.6160000000018044 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [ + 3 + ], + [] + ], + "count": 3, + "cpu_time_us": 3960.6820000000007, + "self_cpu_time_us": 18.923999999969965, + "cuda_time_us": 3.551999999996042, + "self_cuda_time_us": 3.551999999996042 + }, + { + "op": "aten::remainder", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ] + ], + "count": 2, + "cpu_time_us": 36.97799999999552, + "self_cpu_time_us": 24.23899999999412, + "cuda_time_us": 3.519000000000233, + "self_cuda_time_us": 3.519000000000233 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::BinaryFunctor, std::array, false>(int, at::native::BinaryFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3.519000000000233, + "self_cuda_time_us": 3.519000000000233 + }, + { + "op": "aten::remainder", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [] + ], + "count": 2, + "cpu_time_us": 33.4429999999993, + "self_cpu_time_us": 23.146999999997206, + "cuda_time_us": 3.4879999999975553, + "self_cuda_time_us": 3.4879999999975553 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::BUnaryFunctor, std::array, false>(int, at::native::BUnaryFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3.4879999999975553, + "self_cuda_time_us": 3.4879999999975553 + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy_alignedK_contig, unsigned int, 2, 128, 1, 16>(at::native::(anonymous namespace)::OpaqueType<8u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 128, 1>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3.4869999999973516, + "self_cuda_time_us": 3.4869999999973516 + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy_vectorized, unsigned int, 2, 128, 1, 16, 4>(char*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 128, 1>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3.423000000002503, + "self_cuda_time_us": 3.423000000002503 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [ + 1 + ] + ], + "count": 3, + "cpu_time_us": 60.59900000000198, + "self_cpu_time_us": 37.20600000000195, + "cuda_time_us": 3.3290000000015425, + "self_cuda_time_us": 3.3290000000015425 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1 + ], + [ + 2 + ], + [] + ], + "count": 2, + "cpu_time_us": 29.87000000000262, + "self_cpu_time_us": 19.57100000000719, + "cuda_time_us": 3.136000000002241, + "self_cuda_time_us": 3.136000000002241 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#11}::operator()() const::{lambda(bool)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#11}::operator()() const::{lambda(bool)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3.040000000000873, + "self_cuda_time_us": 3.040000000000873 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15, + 20, + 2, + 2 + ], + [ + 15, + 20, + 2, + 2 + ], + [] + ], + "count": 2, + "cpu_time_us": 23.843999999997322, + "self_cpu_time_us": 12.275999999998021, + "cuda_time_us": 3.006999999997788, + "self_cuda_time_us": 3.006999999997788 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3.006999999997788, + "self_cuda_time_us": 3.006999999997788 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 11 + ], + [ + 1, + 456, + 11 + ], + [] + ], + "count": 2, + "cpu_time_us": 23.614000000001397, + "self_cpu_time_us": 13.391999999999825, + "cuda_time_us": 2.9759999999951106, + "self_cuda_time_us": 2.9759999999951106 + }, + { + "op": "aten::gather", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320, + 2560 + ], + [], + [ + 456, + 2560 + ], + [], + [ + 456, + 2560 + ] + ], + "count": 1, + "cpu_time_us": 66.6239999999998, + "self_cpu_time_us": 31.395000000000437, + "cuda_time_us": 2.878999999997177, + "self_cuda_time_us": 2.878999999997177 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 10 + ], + [ + 1, + 456, + 10 + ], + [] + ], + "count": 2, + "cpu_time_us": 17.453999999997905, + "self_cpu_time_us": 9.136999999995169, + "cuda_time_us": 2.8479999999981374, + "self_cuda_time_us": 2.8479999999981374 + }, + { + "op": "aten::gelu", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [] + ], + "count": 1, + "cpu_time_us": 15.406000000002678, + "self_cpu_time_us": 8.715000000003783, + "cuda_time_us": 2.7189999999973224, + "self_cuda_time_us": 2.7189999999973224 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::GeluCUDAKernelImpl(at::TensorIteratorBase&, at::native::GeluType)::{lambda()#2}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array, false>(int, at::native::GeluCUDAKernelImpl(at::TensorIteratorBase&, at::native::GeluType)::{lambda()#2}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2.7189999999973224, + "self_cuda_time_us": 2.7189999999973224 + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceCompactInitKernel, int*>(at_cuda_detail::cub::ScanTileState, int, int*)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 3, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2.7189999999973224, + "self_cuda_time_us": 2.7189999999973224 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ], + [] + ], + "count": 2, + "cpu_time_us": 23.10699999999997, + "self_cpu_time_us": 15.184999999997672, + "cuda_time_us": 2.6229999999995925, + "self_cuda_time_us": 2.6229999999995925 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [] + ], + "count": 1, + "cpu_time_us": 11.63300000000163, + "self_cpu_time_us": 7.633999999998196, + "cuda_time_us": 2.5279999999984284, + "self_cuda_time_us": 2.5279999999984284 + }, + { + "op": "aten::index", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320 + ], + [] + ], + "count": 1, + "cpu_time_us": 38.436000000016065, + "self_cpu_time_us": 24.736000000033528, + "cuda_time_us": 2.526999999972759, + "self_cuda_time_us": 2.526999999972759 + }, + { + "op": "void at::native::index_elementwise_kernel<128, 4, at::native::gpu_index_kernel >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_kernel_impl >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1}>(long, at::native::gpu_index_kernel >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_kernel_impl >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2.526999999972759, + "self_cuda_time_us": 2.526999999972759 + }, + { + "op": "aten::clamp", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [], + [] + ], + "count": 2, + "cpu_time_us": 37.52600000000166, + "self_cpu_time_us": 26.5570000000007, + "cuda_time_us": 2.495999999999185, + "self_cuda_time_us": 2.495999999999185 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [], + [] + ], + "count": 2, + "cpu_time_us": 27.63000000000102, + "self_cpu_time_us": 17.850000000002183, + "cuda_time_us": 2.463999999999942, + "self_cuda_time_us": 2.463999999999942 + }, + { + "op": "aten::floor_divide", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ] + ], + "count": 1, + "cpu_time_us": 17.934000000001106, + "self_cpu_time_us": 8.194000000003143, + "cuda_time_us": 2.4320000000006985, + "self_cuda_time_us": 2.4320000000006985 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::BinaryFunctor, std::array, false>(int, at::native::BinaryFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2.4320000000006985, + "self_cuda_time_us": 2.4320000000006985 + }, + { + "op": "aten::prod", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 31.084999999999127, + "self_cpu_time_us": 22.80000000000291, + "cuda_time_us": 2.4320000000006985, + "self_cuda_time_us": 2.4320000000006985 + }, + { + "op": "reduction_prod_kernel", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2.4320000000006985, + "self_cuda_time_us": 2.4320000000006985 + }, + { + "op": "aten::max", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 456 + ] + ], + "count": 1, + "cpu_time_us": 30.485000000000582, + "self_cpu_time_us": 19.390999999995984, + "cuda_time_us": 2.4320000000006985, + "self_cuda_time_us": 2.4320000000006985 + }, + { + "op": "void at::native::reduce_kernel<512, 1, at::native::ReduceOp >, unsigned int, long, 4, 4> >(at::native::ReduceOp >, unsigned int, long, 4, 4>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2.4320000000006985, + "self_cuda_time_us": 2.4320000000006985 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::BinaryFunctor >, std::array, false>(int, at::native::BinaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2.4319999999970605, + "self_cuda_time_us": 2.4319999999970605 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::launch_clamp_scalar(at::TensorIteratorBase&, c10::Scalar, c10::Scalar, at::native::detail::ClampLimits)::{lambda()#1}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::(anonymous namespace)::launch_clamp_scalar(at::TensorIteratorBase&, c10::Scalar, c10::Scalar, at::native::detail::ClampLimits)::{lambda()#1}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2.335000000002765, + "self_cuda_time_us": 2.335000000002765 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1 + ], + [ + 1200, + 1 + ], + [] + ], + "count": 2, + "cpu_time_us": 24.328999999997905, + "self_cpu_time_us": 15.600000000002183, + "cuda_time_us": 2.334999999999127, + "self_cuda_time_us": 2.334999999999127 + }, + { + "op": "aten::all", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "count": 1, + "cpu_time_us": 24.06500000000233, + "self_cpu_time_us": 15.972000000001572, + "cuda_time_us": 2.3040000000037253, + "self_cuda_time_us": 2.3040000000037253 + }, + { + "op": "void at::native::reduce_kernel<512, 1, at::native::ReduceOp, unsigned int, bool, 4, 4> >(at::native::ReduceOp, unsigned int, bool, 4, 4>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2.3040000000037253, + "self_cuda_time_us": 2.3040000000037253 + }, + { + "op": "aten::floor", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ] + ], + "count": 2, + "cpu_time_us": 29.7029999999977, + "self_cpu_time_us": 19.12800000000061, + "cuda_time_us": 2.271999999997206, + "self_cuda_time_us": 2.271999999997206 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::floor_kernel_cuda(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::floor_kernel_cuda(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2.271999999997206, + "self_cuda_time_us": 2.271999999997206 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [ + 1200, + 2 + ], + [] + ], + "count": 2, + "cpu_time_us": 28.080000000005384, + "self_cpu_time_us": 17.477000000006228, + "cuda_time_us": 2.2400000000016007, + "self_cuda_time_us": 2.2400000000016007 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::CUDAFunctorOnOther_add, std::array, false>(int, at::native::CUDAFunctorOnOther_add, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2.2400000000016007, + "self_cuda_time_us": 2.2400000000016007 + }, + { + "op": "aten::eq", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 2, + "cpu_time_us": 30.166999999994005, + "self_cpu_time_us": 20.203999999997905, + "cuda_time_us": 2.2399999999979627, + "self_cuda_time_us": 2.2399999999979627 + }, + { + "op": "void at::native::unrolled_elementwise_kernel >, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast>(int, at::native::BinaryFunctor >, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2.209000000002561, + "self_cuda_time_us": 2.209000000002561 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 64 + ], + [ + 1, + 456, + 64 + ], + [] + ], + "count": 2, + "cpu_time_us": 17.702999999994063, + "self_cpu_time_us": 9.239999999997963, + "cuda_time_us": 2.2080000000059954, + "self_cuda_time_us": 2.2080000000059954 + }, + { + "op": "aten::abs", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [ + 0 + ] + ], + "count": 2, + "cpu_time_us": 32.9220000000023, + "self_cpu_time_us": 17.135999999998603, + "cuda_time_us": 2.2080000000023574, + "self_cuda_time_us": 2.2080000000023574 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::AbsFunctor, std::array, false>(int, at::native::AbsFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2.2080000000023574, + "self_cuda_time_us": 2.2080000000023574 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456, + 32 + ], + [] + ], + "count": 2, + "cpu_time_us": 31.654999999998836, + "self_cpu_time_us": 22.10399999999936, + "cuda_time_us": 2.176000000006752, + "self_cuda_time_us": 2.176000000006752 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 16 + ], + [] + ], + "count": 2, + "cpu_time_us": 26.386999999998807, + "self_cpu_time_us": 17.503999999997177, + "cuda_time_us": 2.176000000003114, + "self_cuda_time_us": 2.176000000003114 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [ + 3, + 1, + 1, + 456 + ], + [] + ], + "count": 1, + "cpu_time_us": 10.756999999997788, + "self_cpu_time_us": 5.197999999996682, + "cuda_time_us": 2.175999999999476, + "self_cuda_time_us": 2.175999999999476 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 22.05500000000029, + "self_cpu_time_us": 13.73399999999674, + "cuda_time_us": 2.1759999999922, + "self_cuda_time_us": 2.1759999999922 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [ + 1200, + 2, + 1 + ], + [] + ], + "count": 1, + "cpu_time_us": 10.0, + "self_cpu_time_us": 5.049999999999272, + "cuda_time_us": 2.1750000000029104, + "self_cuda_time_us": 2.1750000000029104 + }, + { + "op": "aten::sum", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 1, + "cpu_time_us": 41.08899999999994, + "self_cpu_time_us": 32.913000000000466, + "cuda_time_us": 2.144000000000233, + "self_cuda_time_us": 2.144000000000233 + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy, unsigned int, 3, 64, 64>(at::native::(anonymous namespace)::OpaqueType<8u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 64, 64>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2.014999999999418, + "self_cuda_time_us": 2.014999999999418 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [ + 300, + 2560 + ], + [] + ], + "count": 1, + "cpu_time_us": 8.389999999999418, + "self_cpu_time_us": 4.239000000001397, + "cuda_time_us": 1.951999999997497, + "self_cuda_time_us": 1.951999999997497 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::FillFunctor, std::array, false>(int, at::native::FillFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1.9510000000009313, + "self_cuda_time_us": 1.9510000000009313 + }, + { + "op": "aten::sin", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456, + 32 + ] + ], + "count": 1, + "cpu_time_us": 14.64600000000064, + "self_cpu_time_us": 9.288000000000466, + "cuda_time_us": 1.9199999999982538, + "self_cuda_time_us": 1.9199999999982538 + }, + { + "op": "aten::cos", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456, + 32 + ] + ], + "count": 1, + "cpu_time_us": 21.036000000000058, + "self_cpu_time_us": 13.419999999998254, + "cuda_time_us": 1.919000000001688, + "self_cuda_time_us": 1.919000000001688 + }, + { + "op": "aten::cos", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 16 + ] + ], + "count": 1, + "cpu_time_us": 19.501000000000204, + "self_cpu_time_us": 12.644000000000233, + "cuda_time_us": 1.8880000000026484, + "self_cuda_time_us": 1.8880000000026484 + }, + { + "op": "aten::sin", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 16 + ] + ], + "count": 1, + "cpu_time_us": 19.020999999997002, + "self_cpu_time_us": 12.65599999999904, + "cuda_time_us": 1.8559999999997672, + "self_cuda_time_us": 1.8559999999997672 + }, + { + "op": "aten::index_select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [ + 1 + ] + ], + "count": 1, + "cpu_time_us": 26.63799999999901, + "self_cpu_time_us": 13.975000000002183, + "cuda_time_us": 1.7600000000020373, + "self_cuda_time_us": 1.7600000000020373 + }, + { + "op": "void at::native::(anonymous namespace)::indexSelectSmallIndex(at::cuda::detail::TensorInfo, at::cuda::detail::TensorInfo, at::cuda::detail::TensorInfo, int, int, unsigned int, long)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1.7600000000020373, + "self_cuda_time_us": 1.7600000000020373 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [ + 16 + ] + ], + "count": 1, + "cpu_time_us": 14.635999999998603, + "self_cpu_time_us": 9.723000000001775, + "cuda_time_us": 1.632000000001426, + "self_cuda_time_us": 1.632000000001426 + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceScanKernel >::Policy1000, int const*, int*, at_cuda_detail::cub::ScanTileState, std::plus, at_cuda_detail::cub::NullType, unsigned int, int, false, at_cuda_detail::cub::NullType>(int const*, int*, at_cuda_detail::cub::ScanTileState, int, std::plus, at_cuda_detail::cub::NullType, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1.631999999997788, + "self_cuda_time_us": 1.631999999997788 + }, + { + "op": "_native::bmm_triton_0", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 32, + 1 + ], + [ + 3, + 1, + 456 + ] + ], + "count": 1, + "cpu_time_us": 225.35199999999895, + "self_cpu_time_us": 210.29200000000856, + "cuda_time_us": 1.5679999999993015, + "self_cuda_time_us": 1.5679999999993015 + }, + { + "op": "_bmm_outer_product_kernel", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1.5679999999993015, + "self_cuda_time_us": 1.5679999999993015 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [ + 1200, + 1, + 2 + ], + [] + ], + "count": 1, + "cpu_time_us": 12.200000000000728, + "self_cpu_time_us": 8.096000000001368, + "cuda_time_us": 1.5669999999990978, + "self_cuda_time_us": 1.5669999999990978 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [ + 1200, + 1, + 2 + ] + ], + "count": 1, + "cpu_time_us": 14.109000000000378, + "self_cpu_time_us": 8.746999999999389, + "cuda_time_us": 1.5360000000000582, + "self_cuda_time_us": 1.5360000000000582 + }, + { + "op": "aten::floor_divide", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 1, + "cpu_time_us": 23.431999999993423, + "self_cpu_time_us": 12.398999999990338, + "cuda_time_us": 1.5360000000000582, + "self_cuda_time_us": 1.5360000000000582 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [ + 1, + 3 + ], + [] + ], + "count": 2, + "cpu_time_us": 41.025000000001455, + "self_cpu_time_us": 12.48700000000099, + "cuda_time_us": 1.503999999997177, + "self_cuda_time_us": 1.503999999997177 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 79 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 19.584999999999127, + "self_cpu_time_us": 12.993999999998778, + "cuda_time_us": 1.4400000000023283, + "self_cuda_time_us": 1.4400000000023283 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctorOnSelf_add const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctorOnSelf_add const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1.4400000000023283, + "self_cuda_time_us": 1.4400000000023283 + }, + { + "op": "aten::floor_divide", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 2, + "cpu_time_us": 35.14999999999418, + "self_cpu_time_us": 24.758000000005268, + "cuda_time_us": 1.4399999999950523, + "self_cuda_time_us": 1.4399999999950523 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 77 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 14.90400000000227, + "self_cpu_time_us": 9.653000000005704, + "cuda_time_us": 1.4389999999984866, + "self_cuda_time_us": 1.4389999999984866 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ], + [] + ], + "count": 1, + "cpu_time_us": 23.45799999999872, + "self_cpu_time_us": 15.739000000001397, + "cuda_time_us": 1.3760000000002037, + "self_cuda_time_us": 1.3760000000002037 + }, + { + "op": "void at::native::unrolled_elementwise_kernel, 4, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1> >(int, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#3}::operator()() const::{lambda(int)#1}, std::array, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1.3760000000002037, + "self_cuda_time_us": 1.3760000000002037 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ] + ], + "count": 1, + "cpu_time_us": 14.846999999997934, + "self_cpu_time_us": 9.365999999998166, + "cuda_time_us": 1.3119999999980791, + "self_cuda_time_us": 1.3119999999980791 + }, + { + "op": "aten::gt", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 1, + "cpu_time_us": 20.584999999999127, + "self_cpu_time_us": 14.161999999996624, + "cuda_time_us": 1.2799999999988358, + "self_cuda_time_us": 1.2799999999988358 + }, + { + "op": "void at::native::unrolled_elementwise_kernel, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast>(int, at::native::(anonymous namespace)::CompareFunctor, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1.2799999999988358, + "self_cuda_time_us": 1.2799999999988358 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 1, + "cpu_time_us": 15.027999999998428, + "self_cpu_time_us": 10.088999999999942, + "cuda_time_us": 1.2479999999995925, + "self_cuda_time_us": 1.2479999999995925 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [] + ], + "count": 1, + "cpu_time_us": 12.386000000002241, + "self_cpu_time_us": 8.147000000000844, + "cuda_time_us": 1.2160000000003492, + "self_cuda_time_us": 1.2160000000003492 + }, + { + "op": "aten::add_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 12.66700000000128, + "self_cpu_time_us": 8.326999999997497, + "cuda_time_us": 1.2160000000003492, + "self_cuda_time_us": 1.2160000000003492 + }, + { + "op": "aten::_softmax", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 20.46899999998277, + "self_cpu_time_us": 13.244999999995343, + "cuda_time_us": 1.150999999983469, + "self_cuda_time_us": 1.150999999983469 + }, + { + "op": "void (anonymous namespace)::softmax_warp_forward(float*, float const*, int, int, int, bool const*, int, bool)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1.150999999983469, + "self_cuda_time_us": 1.150999999983469 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 1, + "cpu_time_us": 14.02900000000227, + "self_cpu_time_us": 9.301999999996042, + "cuda_time_us": 1.1200000000026193, + "self_cuda_time_us": 1.1200000000026193 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 11.909999999996217, + "self_cpu_time_us": 7.294000000001688, + "cuda_time_us": 1.1200000000026193, + "self_cuda_time_us": 1.1200000000026193 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 11.296999999998661, + "self_cpu_time_us": 7.538999999997031, + "cuda_time_us": 1.088000000003376, + "self_cuda_time_us": 1.088000000003376 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 20 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 10.477999999995518, + "self_cpu_time_us": 6.4099999999962165, + "cuda_time_us": 1.0879999999961, + "self_cuda_time_us": 1.0879999999961 + }, + { + "op": "aten::add_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 8.886999999995169, + "self_cpu_time_us": 4.826000000000931, + "cuda_time_us": 1.0879999999961, + "self_cuda_time_us": 1.0879999999961 + }, + { + "op": "at::native::(anonymous namespace)::masked_scatter_size_check(long const*, bool const*, long)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1.0560000000041327, + "self_cuda_time_us": 1.0560000000041327 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 1200, + 2 + ], + [ + 1, + 1, + 1200, + 2 + ], + [] + ], + "count": 1, + "cpu_time_us": 14.43500000000131, + "self_cpu_time_us": 3.4030000000020664, + "cuda_time_us": 0.9919999999983702, + "self_cuda_time_us": 0.9919999999983702 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456 + ], + [] + ], + "count": 1, + "cpu_time_us": 11.694999999999709, + "self_cpu_time_us": 5.788000000000466, + "cuda_time_us": 0.9910000000018044, + "self_cuda_time_us": 0.9910000000018044 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2 + ], + [] + ], + "count": 1, + "cpu_time_us": 13.510000000002037, + "self_cpu_time_us": 7.894000000000233, + "cuda_time_us": 0.9600000000027649, + "self_cuda_time_us": 0.9600000000027649 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::FillFunctor, std::array, false>(int, at::native::FillFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 0.9600000000027649, + "self_cuda_time_us": 0.9600000000027649 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 2, + "cpu_time_us": 18.43500000000131, + "self_cpu_time_us": 10.781000000002678, + "cuda_time_us": 0.9599999999991269, + "self_cuda_time_us": 0.9599999999991269 + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceScanInitKernel >(at_cuda_detail::cub::ScanTileState, int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 0.8960000000006403, + "self_cuda_time_us": 0.8960000000006403 + }, + { + "op": "cua.prepare", + "device_type": "DeviceType.CPU", + "is_user_annotation": true, + "input_shapes": [], + "count": 1, + "cpu_time_us": 8934.872, + "self_cpu_time_us": 5470.230999999989, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::lift_fresh", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 480, + 640, + 3 + ] + ], + "count": 1, + "cpu_time_us": 5.248999999999796, + "self_cpu_time_us": 5.248999999999796, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 480, + 640, + 3 + ], + [], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.7070000000003347, + "self_cpu_time_us": 0.7070000000003347, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 480, + 640, + 3 + ], + [] + ], + "count": 1, + "cpu_time_us": 6.877999999998792, + "self_cpu_time_us": 6.877999999998792, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::permute", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 480, + 640, + 3 + ], + [] + ], + "count": 1, + "cpu_time_us": 15.06800000000112, + "self_cpu_time_us": 11.931000000002314, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 480, + 640, + 3 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 3.1369999999988067, + "self_cpu_time_us": 3.1369999999988067, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 480, + 640 + ], + [] + ], + "count": 2, + "cpu_time_us": 9.239999999999782, + "self_cpu_time_us": 7.602999999999156, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 480, + 640 + ], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 1.6370000000006257, + "self_cpu_time_us": 1.6370000000006257, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 7.197000000000116, + "self_cpu_time_us": 6.492000000000189, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.7049999999999272, + "self_cpu_time_us": 0.7049999999999272, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 800.5730000000003, + "self_cpu_time_us": 3.0830000000005384, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 797.4899999999998, + "self_cpu_time_us": 15.48699999999917, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::empty_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [], + [] + ], + "count": 1040, + "cpu_time_us": 4203.923999999748, + "self_cpu_time_us": 4203.923999999748, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [ + 1, + 3, + 480, + 640 + ], + [] + ], + "count": 1, + "cpu_time_us": 770.8060000000005, + "self_cpu_time_us": 770.8060000000005, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [], + [], + [], + [] + ], + "count": 3, + "cpu_time_us": 3937.8560000000016, + "self_cpu_time_us": 2.3950000000204454, + "cuda_time_us": 0.35199999998440035, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [] + ], + "count": 3, + "cpu_time_us": 6.072999999985768, + "self_cpu_time_us": 6.072999999985768, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [ + 3, + 1, + 1 + ], + [] + ], + "count": 1, + "cpu_time_us": 708.0990000000002, + "self_cpu_time_us": 708.0990000000002, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::div_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [ + 3, + 1, + 1 + ] + ], + "count": 1, + "cpu_time_us": 263.73099999999977, + "self_cpu_time_us": 263.73099999999977, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [] + ], + "count": 1, + "cpu_time_us": 17.329000000001543, + "self_cpu_time_us": 11.582000000000335, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 5.747000000001208, + "self_cpu_time_us": 5.747000000001208, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::permute", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 15, + 2, + 16, + 20, + 2, + 16 + ], + [] + ], + "count": 1, + "cpu_time_us": 6.470000000001164, + "self_cpu_time_us": 4.981999999999971, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 15, + 2, + 16, + 20, + 2, + 16 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 1.4880000000011933, + "self_cpu_time_us": 1.4880000000011933, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 16, + 16 + ], + [] + ], + "count": 1, + "cpu_time_us": 5.031000000000859, + "self_cpu_time_us": 3.868000000000393, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 16, + 16 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 1.1630000000004657, + "self_cpu_time_us": 1.1630000000004657, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 1, + 16, + 16 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 7.307999999999083, + "self_cpu_time_us": 6.020999999998821, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 1, + 16, + 16 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 1.287000000000262, + "self_cpu_time_us": 1.287000000000262, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 2, + 16, + 16 + ], + [] + ], + "count": 1, + "cpu_time_us": 1513.186999999998, + "self_cpu_time_us": 10.024999999997817, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 2, + 16, + 16 + ], + [] + ], + "count": 1, + "cpu_time_us": 1500.5139999999992, + "self_cpu_time_us": 17.09899999999834, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 2, + 16, + 16 + ], + [], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 12.550000000001091, + "self_cpu_time_us": 4.1380000000008295, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::empty", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [], + [] + ], + "count": 973, + "cpu_time_us": 3755.9359999999324, + "self_cpu_time_us": 3755.9359999999324, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 2, + 16, + 16 + ], + [ + 1, + 15, + 20, + 2, + 2, + 3, + 2, + 16, + 16 + ], + [] + ], + "count": 1, + "cpu_time_us": 1470.8649999999998, + "self_cpu_time_us": 1470.8649999999998, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 2, + 16, + 16 + ], + [] + ], + "count": 1, + "cpu_time_us": 2.6480000000010477, + "self_cpu_time_us": 2.6480000000010477, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 1536 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 6.570999999999913, + "self_cpu_time_us": 5.585999999999331, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 1536 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.9850000000005821, + "self_cpu_time_us": 0.9850000000005821, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.34099999999671127, + "self_cpu_time_us": 0.34099999999671127, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::lift_fresh", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ] + ], + "count": 1, + "cpu_time_us": 0.34800000000177533, + "self_cpu_time_us": 0.34800000000177533, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ] + ], + "count": 1, + "cpu_time_us": 3.280000000002474, + "self_cpu_time_us": 2.0709999999999127, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ] + ], + "count": 1, + "cpu_time_us": 1.2090000000025611, + "self_cpu_time_us": 1.2090000000025611, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [], + [] + ], + "count": 10, + "cpu_time_us": 46.97299999999814, + "self_cpu_time_us": 40.088999999992666, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [], + [], + [] + ], + "count": 10, + "cpu_time_us": 6.8840000000054715, + "self_cpu_time_us": 6.8840000000054715, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::prod", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [] + ], + "count": 1, + "cpu_time_us": 22.31499999999869, + "self_cpu_time_us": 18.828999999997905, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [] + ], + "count": 7, + "cpu_time_us": 4.002000000004045, + "self_cpu_time_us": 4.002000000004045, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::item", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [] + ], + "count": 19, + "cpu_time_us": 306.75300000001516, + "self_cpu_time_us": 36.38000000002285, + "cuda_time_us": 18.653999999991356, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [], + [], + [], + [] + ], + "count": 4, + "cpu_time_us": 29.39799999999741, + "self_cpu_time_us": 2.7599999999983993, + "cuda_time_us": 2.0800000000017462, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::lift_fresh", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "count": 3, + "cpu_time_us": 0.6290000000008149, + "self_cpu_time_us": 0.6290000000008149, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "count": 3, + "cpu_time_us": 6.588999999999942, + "self_cpu_time_us": 4.602999999999156, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "count": 3, + "cpu_time_us": 1.9860000000007858, + "self_cpu_time_us": 1.9860000000007858, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_conj", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "count": 1, + "cpu_time_us": 0.9939999999987776, + "self_cpu_time_us": 0.9939999999987776, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "count": 1, + "cpu_time_us": 0.4360000000015134, + "self_cpu_time_us": 0.4360000000015134, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unbind", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "count": 2, + "cpu_time_us": 17.413000000000466, + "self_cpu_time_us": 9.516999999999825, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [] + ], + "count": 6, + "cpu_time_us": 20.443999999995867, + "self_cpu_time_us": 17.117999999998574, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [], + [] + ], + "count": 11, + "cpu_time_us": 6.515000000003056, + "self_cpu_time_us": 6.515000000003056, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_conj", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ] + ], + "count": 2, + "cpu_time_us": 0.5129999999990105, + "self_cpu_time_us": 0.5129999999990105, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ] + ], + "count": 2, + "cpu_time_us": 0.3340000000061991, + "self_cpu_time_us": 0.3340000000061991, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cua.transfer", + "device_type": "DeviceType.CPU", + "is_user_annotation": true, + "input_shapes": [], + "count": 1, + "cpu_time_us": 1492.8840000000018, + "self_cpu_time_us": 143.2689999999966, + "cuda_time_us": 678.0650000000023, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 3, + "cpu_time_us": 479.82000000000335, + "self_cpu_time_us": 8.84700000000521, + "cuda_time_us": 1.7270000000025902, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 7, + "cpu_time_us": 557.4939999999915, + "self_cpu_time_us": 39.71799999997529, + "cuda_time_us": 10.3340000000062, + "self_cuda_time_us": 0.0 + }, + { + "op": "Activity Buffer Request", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 291.3130000000019, + "self_cpu_time_us": 291.3130000000019, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaMemcpyAsync", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 188, + "cpu_time_us": 2930.7169999999933, + "self_cpu_time_us": 2930.7169999999933, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaStreamSynchronize", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 106, + "cpu_time_us": 4137.034999999949, + "self_cpu_time_us": 4137.034999999949, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1536 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 826.9570000000022, + "self_cpu_time_us": 2.308000000000902, + "cuda_time_us": 675.9540000000015, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1536 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 858.4010000000017, + "self_cpu_time_us": 14.391999999999825, + "cuda_time_us": 684.4330000000009, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 68.79799999999886, + "self_cpu_time_us": 4.518000000000029, + "cuda_time_us": 1.503999999997177, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 64.27999999999884, + "self_cpu_time_us": 11.031999999995605, + "cuda_time_us": 1.503999999997177, + "self_cuda_time_us": 0.0 + }, + { + "op": "cua.forward", + "device_type": "DeviceType.CPU", + "is_user_annotation": true, + "input_shapes": [], + "count": 1, + "cpu_time_us": 222739.24000000002, + "self_cpu_time_us": 1143.954000000056, + "cuda_time_us": 83948.13799999948, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::embedding", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320, + 2560 + ], + [ + 1, + 456 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 139.11699999999837, + "self_cpu_time_us": 16.947000000000116, + "cuda_time_us": 2.878999999997177, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "count": 1, + "cpu_time_us": 5.2959999999984575, + "self_cpu_time_us": 2.9140000000006694, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "count": 1, + "cpu_time_us": 2.381999999997788, + "self_cpu_time_us": 2.381999999997788, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::index_select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320, + 2560 + ], + [], + [ + 456 + ] + ], + "count": 1, + "cpu_time_us": 116.06200000000172, + "self_cpu_time_us": 27.890000000003056, + "cuda_time_us": 2.878999999997177, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::resize_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ], + [], + [] + ], + "count": 190, + "cpu_time_us": 658.1080000000838, + "self_cpu_time_us": 658.1080000000838, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [] + ], + "count": 4, + "cpu_time_us": 2.9830000000001746, + "self_cpu_time_us": 2.9830000000001746, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 1 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 7.2370000000009895, + "self_cpu_time_us": 4.761000000002241, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 1 + ], + [], + [], + [] + ], + "count": 4, + "cpu_time_us": 3.598999999998341, + "self_cpu_time_us": 3.598999999998341, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.5469999999986612, + "self_cpu_time_us": 0.5469999999986612, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320, + 2560 + ], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 1.6539999999877182, + "self_cpu_time_us": 1.6539999999877182, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaLaunchKernel", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 6884, + "cpu_time_us": 31485.07700000168, + "self_cpu_time_us": 31485.07700000168, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [] + ], + "count": 1, + "cpu_time_us": 0.8119999999980791, + "self_cpu_time_us": 0.8119999999980791, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1536 + ], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 36.51199999999881, + "self_cpu_time_us": 2.7599999999983993, + "cuda_time_us": 8.47899999999936, + "self_cuda_time_us": 0.0 + }, + { + "op": "cua.vision", + "device_type": "DeviceType.CPU", + "is_user_annotation": true, + "input_shapes": [], + "count": 1, + "cpu_time_us": 37399.621, + "self_cpu_time_us": 11289.067000000094, + "cuda_time_us": 14948.241999999991, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::repeat_interleave", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [ + 1 + ], + [], + [] + ], + "count": 4, + "cpu_time_us": 889.3539999999994, + "self_cpu_time_us": 46.49699999999575, + "cuda_time_us": 43.161999999996624, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::flatten", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [] + ], + "count": 4, + "cpu_time_us": 1.364000000001397, + "self_cpu_time_us": 1.364000000001397, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 4, + "cpu_time_us": 13.895000000000437, + "self_cpu_time_us": 6.8770000000004075, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 9, + "cpu_time_us": 11.322000000000116, + "self_cpu_time_us": 11.322000000000116, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [] + ], + "count": 5, + "cpu_time_us": 20.176000000003114, + "self_cpu_time_us": 17.254000000004453, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 9.913000000000466, + "self_cpu_time_us": 9.913000000000466, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [], + [] + ], + "count": 6, + "cpu_time_us": 25.529999999998836, + "self_cpu_time_us": 3.5799999999981083, + "cuda_time_us": 1.3760000000002037, + "self_cuda_time_us": 0.0 + }, + { + "op": "cudaPeekAtLastError", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 48, + "cpu_time_us": 5.914999999986321, + "self_cpu_time_us": 5.914999999986321, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 7, + "cpu_time_us": 13.63100000000486, + "self_cpu_time_us": 13.63100000000486, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaDeviceGetAttribute", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 87, + "cpu_time_us": 66.10799999992014, + "self_cpu_time_us": 66.10799999992014, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [] + ], + "count": 4, + "cpu_time_us": 13.280999999995402, + "self_cpu_time_us": 10.88399999999092, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::all", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ] + ], + "count": 4, + "cpu_time_us": 108.15799999999581, + "self_cpu_time_us": 43.13400000000547, + "cuda_time_us": 4.1929999999956635, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view_as", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 4, + "cpu_time_us": 9.99399999999514, + "self_cpu_time_us": 7.455999999991036, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [] + ], + "count": 5, + "cpu_time_us": 1.0819999999948777, + "self_cpu_time_us": 1.0819999999948777, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::index_select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [ + 1200 + ] + ], + "count": 3, + "cpu_time_us": 137.70200000000114, + "self_cpu_time_us": 47.33600000000661, + "cuda_time_us": 9.18199999999706, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [] + ], + "count": 101, + "cpu_time_us": 56.75099999999293, + "self_cpu_time_us": 56.75099999999293, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [], + [] + ], + "count": 3, + "cpu_time_us": 8.703999999994267, + "self_cpu_time_us": 6.539999999993597, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [], + [], + [] + ], + "count": 14, + "cpu_time_us": 7.1780000000071595, + "self_cpu_time_us": 7.1780000000071595, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 11.774999999997817, + "self_cpu_time_us": 10.193999999999505, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::pad", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 47.05500000000029, + "self_cpu_time_us": 5.935999999997875, + "cuda_time_us": 0.9599999999991269, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::constant_pad_nd", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 41.119000000002416, + "self_cpu_time_us": 11.450999999997293, + "cuda_time_us": 0.9599999999991269, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 6.663000000000466, + "self_cpu_time_us": 3.3400000000001455, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ], + [ + 0 + ], + [] + ], + "count": 17, + "cpu_time_us": 16.716999999964173, + "self_cpu_time_us": 16.716999999964173, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::arange", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [] + ], + "count": 9, + "cpu_time_us": 179.41600000000108, + "self_cpu_time_us": 31.18900000001304, + "cuda_time_us": 7.423000000002503, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [], + [], + [], + [] + ], + "count": 6, + "cpu_time_us": 82.34500000000116, + "self_cpu_time_us": 6.063000000001921, + "cuda_time_us": 8.54200000000128, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 4, + "cpu_time_us": 76.28199999999924, + "self_cpu_time_us": 16.981999999996333, + "cuda_time_us": 8.54200000000128, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::arange", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 36.757000000001426, + "self_cpu_time_us": 7.084000000002561, + "cuda_time_us": 1.8879999999990105, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [] + ], + "count": 8, + "cpu_time_us": 21.485000000000582, + "self_cpu_time_us": 17.7229999999945, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [], + [], + [] + ], + "count": 4, + "cpu_time_us": 1.4389999999984866, + "self_cpu_time_us": 1.4389999999984866, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::abs", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ] + ], + "count": 2, + "cpu_time_us": 49.77000000000044, + "self_cpu_time_us": 10.904999999998836, + "cuda_time_us": 2.2080000000023574, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::rsub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [] + ], + "count": 2, + "cpu_time_us": 35.93999999999869, + "self_cpu_time_us": 7.859999999993306, + "cuda_time_us": 2.2400000000016007, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [] + ], + "count": 5, + "cpu_time_us": 12.645000000000437, + "self_cpu_time_us": 10.3849999999984, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [], + [] + ], + "count": 9, + "cpu_time_us": 4.3729999999995925, + "self_cpu_time_us": 4.3729999999995925, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 2 + ], + [] + ], + "count": 2, + "cpu_time_us": 6.275999999994383, + "self_cpu_time_us": 3.0789999999942665, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 2 + ], + [] + ], + "count": 2, + "cpu_time_us": 3.1970000000001164, + "self_cpu_time_us": 3.1970000000001164, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 54.31699999999546, + "self_cpu_time_us": 3.172999999998865, + "cuda_time_us": 0.7360000000007858, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 77, + "cpu_time_us": 1637.5149999999812, + "self_cpu_time_us": 215.22200000001612, + "cuda_time_us": 76.9870000000119, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::lift_fresh", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ] + ], + "count": 2, + "cpu_time_us": 0.7099999999954889, + "self_cpu_time_us": 0.7099999999954889, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ] + ], + "count": 2, + "cpu_time_us": 5.423999999995431, + "self_cpu_time_us": 3.3739999999961583, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ] + ], + "count": 2, + "cpu_time_us": 2.0499999999992724, + "self_cpu_time_us": 2.0499999999992724, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_conj", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ] + ], + "count": 1, + "cpu_time_us": 0.33400000000256114, + "self_cpu_time_us": 0.33400000000256114, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ] + ], + "count": 1, + "cpu_time_us": 0.18100000000049477, + "self_cpu_time_us": 0.18100000000049477, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_conj", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ] + ], + "count": 74, + "cpu_time_us": 13.374000000003434, + "self_cpu_time_us": 13.374000000003434, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ] + ], + "count": 74, + "cpu_time_us": 9.936000000005151, + "self_cpu_time_us": 9.936000000005151, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 74, + "cpu_time_us": 1645.4320000000153, + "self_cpu_time_us": 81.01100000003134, + "cuda_time_us": 74.87500000001091, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::meshgrid", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 2, + "cpu_time_us": 35.14299999999639, + "self_cpu_time_us": 15.535000000010768, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 30 + ], + [] + ], + "count": 1, + "cpu_time_us": 1.370999999999185, + "self_cpu_time_us": 1.370999999999185, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 30, + 1 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 3.6890000000021246, + "self_cpu_time_us": 2.905000000002474, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 30, + 1 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.7839999999996508, + "self_cpu_time_us": 0.7839999999996508, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 40 + ], + [] + ], + "count": 1, + "cpu_time_us": 0.8139999999984866, + "self_cpu_time_us": 0.8139999999984866, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 40 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 2.2550000000010186, + "self_cpu_time_us": 1.827000000001135, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 40 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.4279999999998836, + "self_cpu_time_us": 0.4279999999998836, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 30, + 40 + ], + [] + ], + "count": 2, + "cpu_time_us": 12.528999999998632, + "self_cpu_time_us": 7.804000000003725, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 30, + 40 + ], + [], + [] + ], + "count": 2, + "cpu_time_us": 4.724999999994907, + "self_cpu_time_us": 4.724999999994907, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15, + 2, + 20, + 2 + ], + [], + [] + ], + "count": 2, + "cpu_time_us": 8.654999999998836, + "self_cpu_time_us": 7.080000000001746, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15, + 2, + 20, + 2 + ], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 1.5749999999970896, + "self_cpu_time_us": 1.5749999999970896, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::flatten", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15, + 20, + 2, + 2 + ], + [], + [] + ], + "count": 2, + "cpu_time_us": 54.948999999996886, + "self_cpu_time_us": 7.794999999998254, + "cuda_time_us": 3.006999999997788, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15, + 20, + 2, + 2 + ], + [] + ], + "count": 2, + "cpu_time_us": 44.789999999997235, + "self_cpu_time_us": 7.7959999999948195, + "cuda_time_us": 3.006999999997788, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15, + 20, + 2, + 2 + ], + [], + [], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 13.150000000005093, + "self_cpu_time_us": 3.478000000006432, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15, + 20, + 2, + 2 + ], + [] + ], + "count": 2, + "cpu_time_us": 2.364000000001397, + "self_cpu_time_us": 2.364000000001397, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::stack", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 2, + "cpu_time_us": 63.004000000000815, + "self_cpu_time_us": 16.14300000000003, + "cuda_time_us": 3.7109999999993306, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::repeat", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [] + ], + "count": 1, + "cpu_time_us": 119.43299999999726, + "self_cpu_time_us": 23.838000000007014, + "cuda_time_us": 0.9919999999983702, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [] + ], + "count": 2, + "cpu_time_us": 4.712999999999738, + "self_cpu_time_us": 3.6939999999995052, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unfold", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 3.459999999999127, + "self_cpu_time_us": 2.7700000000004366, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unfold", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 2, + 1200 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 2.175999999999476, + "self_cpu_time_us": 1.683999999997468, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 2, + 1200 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.49200000000200816, + "self_cpu_time_us": 0.49200000000200816, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand_as", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [ + 1, + 1, + 1200, + 2 + ] + ], + "count": 1, + "cpu_time_us": 4.276999999998225, + "self_cpu_time_us": 2.1479999999974098, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 11.150000000001455, + "self_cpu_time_us": 11.150000000001455, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2 + ], + [] + ], + "count": 2, + "cpu_time_us": 12.946999999996478, + "self_cpu_time_us": 2.7919999999940046, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2 + ], + [], + [], + [] + ], + "count": 51, + "cpu_time_us": 35.24799999994866, + "self_cpu_time_us": 35.24799999994866, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2, + 2 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 6.755000000001019, + "self_cpu_time_us": 3.3850000000020373, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2, + 2 + ], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 3.3699999999989814, + "self_cpu_time_us": 2.7549999999973807, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2, + 2 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.6150000000016007, + "self_cpu_time_us": 0.6150000000016007, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::flatten", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2, + 2 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 2.3549999999995634, + "self_cpu_time_us": 1.5859999999993306, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2, + 2 + ], + [] + ], + "count": 1, + "cpu_time_us": 0.7690000000002328, + "self_cpu_time_us": 0.7690000000002328, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::permute", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 1200, + 2 + ], + [] + ], + "count": 1, + "cpu_time_us": 2.721000000001368, + "self_cpu_time_us": 2.2619999999988067, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 1200, + 2 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.45900000000256114, + "self_cpu_time_us": 0.45900000000256114, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 1, + 2 + ], + [] + ], + "count": 1, + "cpu_time_us": 1.4549999999981083, + "self_cpu_time_us": 0.9619999999958964, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 1, + 2 + ], + [] + ], + "count": 1, + "cpu_time_us": 0.4930000000022119, + "self_cpu_time_us": 0.4930000000022119, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 3.25800000000163, + "self_cpu_time_us": 1.243000000002212, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 2.014999999999418, + "self_cpu_time_us": 1.6110000000007858, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::pad", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 41.98099999999977, + "self_cpu_time_us": 3.3649999999979627, + "cuda_time_us": 1.9510000000045693, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::constant_pad_nd", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 38.616000000001804, + "self_cpu_time_us": 7.423000000002503, + "cuda_time_us": 1.9510000000045693, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 4.671999999998661, + "self_cpu_time_us": 1.9939999999987776, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2 + ], + [], + [], + [], + [] + ], + "count": 49, + "cpu_time_us": 151.112000000001, + "self_cpu_time_us": 126.0190000000548, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1536 + ], + [] + ], + "count": 1, + "cpu_time_us": 2.629000000000815, + "self_cpu_time_us": 2.629000000000815, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3, + 2, + 16, + 16 + ], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.41700000000128057, + "self_cpu_time_us": 0.41700000000128057, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::conv3d", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3, + 2, + 16, + 16 + ], + [ + 1024, + 3, + 2, + 16, + 16 + ], + [ + 1024 + ], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 224.60099999999875, + "self_cpu_time_us": 7.306000000000495, + "cuda_time_us": 913.3660000000091, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::convolution", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3, + 2, + 16, + 16 + ], + [ + 1024, + 3, + 2, + 16, + 16 + ], + [ + 1024 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 217.29499999999825, + "self_cpu_time_us": 8.682999999997264, + "cuda_time_us": 913.3660000000091, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_convolution", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3, + 2, + 16, + 16 + ], + [ + 1024, + 3, + 2, + 16, + 16 + ], + [ + 1024 + ], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 208.612000000001, + "self_cpu_time_us": 18.574000000000524, + "cuda_time_us": 913.3660000000091, + "self_cuda_time_us": 0.0 + }, + { + "op": "cudaMemsetAsync", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 196, + "cpu_time_us": 1030.3220000001893, + "self_cpu_time_us": 1030.3220000001893, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaGetErrorString", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 4, + "cpu_time_us": 1.0529999999962456, + "self_cpu_time_us": 1.0529999999962456, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaFuncGetAttributes", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 10.375, + "self_cpu_time_us": 10.375, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaLaunchKernelExC", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 227, + "cpu_time_us": 1069.1020000000972, + "self_cpu_time_us": 1069.1020000000972, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024 + ], + [] + ], + "count": 1, + "cpu_time_us": 2.364000000001397, + "self_cpu_time_us": 1.2920000000012806, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024 + ], + [] + ], + "count": 1, + "cpu_time_us": 1.0720000000001164, + "self_cpu_time_us": 1.0720000000001164, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024, + 1, + 1, + 1 + ], + [] + ], + "count": 1, + "cpu_time_us": 1.6790000000000873, + "self_cpu_time_us": 1.6790000000000873, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::embedding", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2304, + 1024 + ], + [ + 1200, + 4 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 77.73300000000017, + "self_cpu_time_us": 6.601999999998952, + "cuda_time_us": 7.070999999999913, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4 + ], + [] + ], + "count": 1, + "cpu_time_us": 1.6450000000004366, + "self_cpu_time_us": 1.0999999999985448, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4 + ], + [] + ], + "count": 1, + "cpu_time_us": 0.5450000000018917, + "self_cpu_time_us": 0.5450000000018917, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::index_select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2304, + 1024 + ], + [], + [ + 4800 + ] + ], + "count": 1, + "cpu_time_us": 68.91600000000108, + "self_cpu_time_us": 38.757000000005064, + "cuda_time_us": 7.070999999999913, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4800 + ], + [] + ], + "count": 1, + "cpu_time_us": 0.48099999999976717, + "self_cpu_time_us": 0.48099999999976717, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4800, + 1 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 3.2079999999987194, + "self_cpu_time_us": 2.223999999998341, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4800, + 1 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.9840000000003783, + "self_cpu_time_us": 0.9840000000003783, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4800, + 1024 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.3569999999999709, + "self_cpu_time_us": 0.3569999999999709, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2304, + 1024 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.407999999999447, + "self_cpu_time_us": 0.407999999999447, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4800, + 1024 + ], + [] + ], + "count": 1, + "cpu_time_us": 0.569999999999709, + "self_cpu_time_us": 0.569999999999709, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4 + ], + [] + ], + "count": 1, + "cpu_time_us": 3.9580000000023574, + "self_cpu_time_us": 3.4900000000052387, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.4679999999971187, + "self_cpu_time_us": 0.4679999999971187, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.42599999999947613, + "self_cpu_time_us": 0.42599999999947613, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [], + [], + [] + ], + "count": 49, + "cpu_time_us": 932.1610000000001, + "self_cpu_time_us": 76.08199999997305, + "cuda_time_us": 175.4969999999994, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 49, + "cpu_time_us": 856.079000000027, + "self_cpu_time_us": 186.91200000002573, + "cuda_time_us": 175.4969999999994, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 19.406999999999243, + "self_cpu_time_us": 1.33100000000195, + "cuda_time_us": 2.1750000000029104, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 18.075999999997293, + "self_cpu_time_us": 3.356999999999971, + "cuda_time_us": 2.1750000000029104, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16 + ], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.36700000000200816, + "self_cpu_time_us": 0.36700000000200816, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 16 + ], + [], + [] + ], + "count": 4, + "cpu_time_us": 13.055000000000291, + "self_cpu_time_us": 10.994999999998981, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 16 + ], + [], + [], + [] + ], + "count": 4, + "cpu_time_us": 2.0600000000013097, + "self_cpu_time_us": 2.0600000000013097, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [] + ], + "count": 1, + "cpu_time_us": 3.4279999999998836, + "self_cpu_time_us": 1.7269999999989523, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [] + ], + "count": 2, + "cpu_time_us": 3.4910000000018044, + "self_cpu_time_us": 3.4910000000018044, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::layer_norm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [ + 1024 + ], + [ + 1024 + ], + [], + [] + ], + "count": 49, + "cpu_time_us": 1708.2300000000105, + "self_cpu_time_us": 194.15000000002328, + "cuda_time_us": 228.90100000003076, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 3072, + 1024 + ], + [ + 3072 + ] + ], + "count": 24, + "cpu_time_us": 700.1070000000182, + "self_cpu_time_us": 62.33400000002439, + "cuda_time_us": 1453.2719999999863, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3072, + 1024 + ] + ], + "count": 24, + "cpu_time_us": 91.50199999998586, + "self_cpu_time_us": 41.98899999997229, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3072, + 1024 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 49.51300000001356, + "self_cpu_time_us": 38.07100000002538, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3072, + 1024 + ], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 11.441999999988184, + "self_cpu_time_us": 11.441999999988184, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaOccupancyMaxActiveBlocksPerMultiprocessor", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 275, + "cpu_time_us": 301.1369999999697, + "self_cpu_time_us": 301.1369999999697, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3072 + ], + [] + ], + "count": 24, + "cpu_time_us": 85.8450000000048, + "self_cpu_time_us": 40.04800000000614, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3072 + ], + [] + ], + "count": 24, + "cpu_time_us": 45.79699999999866, + "self_cpu_time_us": 45.79699999999866, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::permute", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3, + 16, + 64 + ], + [] + ], + "count": 24, + "cpu_time_us": 119.05500000000757, + "self_cpu_time_us": 99.94800000000032, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3, + 16, + 64 + ], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 19.107000000007247, + "self_cpu_time_us": 19.107000000007247, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unbind", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1200, + 16, + 64 + ], + [] + ], + "count": 24, + "cpu_time_us": 336.7990000000027, + "self_cpu_time_us": 139.39800000002288, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1200, + 16, + 64 + ], + [], + [] + ], + "count": 72, + "cpu_time_us": 197.40099999997983, + "self_cpu_time_us": 153.75799999999072, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1200, + 16, + 64 + ], + [], + [], + [] + ], + "count": 72, + "cpu_time_us": 43.642999999989115, + "self_cpu_time_us": 43.642999999989115, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [], + [], + [], + [] + ], + "count": 96, + "cpu_time_us": 1738.5099999999766, + "self_cpu_time_us": 125.44299999995201, + "cuda_time_us": 377.4910000000418, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 96, + "cpu_time_us": 1613.0670000000246, + "self_cpu_time_us": 359.983000000022, + "cuda_time_us": 377.4910000000418, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 64 + ], + [] + ], + "count": 48, + "cpu_time_us": 152.93100000001505, + "self_cpu_time_us": 128.00499999998647, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 64 + ], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 24.92600000002858, + "self_cpu_time_us": 24.92600000002858, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1, + 64 + ], + [], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 15.760000000005675, + "self_cpu_time_us": 15.760000000005675, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [], + [], + [], + [] + ], + "count": 96, + "cpu_time_us": 327.3480000000018, + "self_cpu_time_us": 279.1390000000174, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [], + [], + [] + ], + "count": 168, + "cpu_time_us": 86.35999999997512, + "self_cpu_time_us": 86.35999999997512, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [], + [] + ], + "count": 72, + "cpu_time_us": 206.9409999999807, + "self_cpu_time_us": 168.78999999998996, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 1200, + 64 + ], + [] + ], + "count": 72, + "cpu_time_us": 221.23599999998623, + "self_cpu_time_us": 181.32600000001548, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 1200, + 64 + ], + [], + [], + [] + ], + "count": 72, + "cpu_time_us": 39.90999999997075, + "self_cpu_time_us": 39.90999999997075, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::split_with_sizes", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 1200, + 64 + ], + [], + [] + ], + "count": 72, + "cpu_time_us": 242.8740000000289, + "self_cpu_time_us": 197.9019999999873, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 1200, + 64 + ], + [], + [], + [] + ], + "count": 168, + "cpu_time_us": 91.31400000002759, + "self_cpu_time_us": 91.31400000002759, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::scaled_dot_product_attention", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 1200, + 64 + ], + [ + 1, + 16, + 1200, + 64 + ], + [ + 1, + 16, + 1200, + 64 + ], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 1854.934000000012, + "self_cpu_time_us": 298.22200000002704, + "cuda_time_us": 1954.7839999999924, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_scaled_dot_product_flash_attention", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 1200, + 64 + ], + [ + 1, + 16, + 1200, + 64 + ], + [ + 1, + 16, + 1200, + 64 + ], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 1556.711999999985, + "self_cpu_time_us": 219.453000000045, + "cuda_time_us": 1954.7839999999924, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 1200, + 64 + ], + [], + [] + ], + "count": 96, + "cpu_time_us": 254.35999999997148, + "self_cpu_time_us": 208.01799999998548, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 160.96099999996295, + "self_cpu_time_us": 47.89099999994869, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaFuncSetAttribute", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 32, + "cpu_time_us": 94.81700000000637, + "self_cpu_time_us": 94.81700000000637, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 51.829999999983556, + "self_cpu_time_us": 38.33299999998053, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 25.054000000021915, + "self_cpu_time_us": 25.054000000021915, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 115.85999999999694, + "self_cpu_time_us": 57.696000000014465, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 58.16399999998248, + "self_cpu_time_us": 46.60699999996359, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [] + ], + "count": 24, + "cpu_time_us": 93.57999999997628, + "self_cpu_time_us": 41.374999999992724, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [] + ], + "count": 24, + "cpu_time_us": 52.204999999983556, + "self_cpu_time_us": 52.204999999983556, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 1024, + 1024 + ], + [ + 1024 + ] + ], + "count": 24, + "cpu_time_us": 1095.7760000000053, + "self_cpu_time_us": 75.3469999999761, + "cuda_time_us": 617.235000000026, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 1024 + ] + ], + "count": 24, + "cpu_time_us": 104.39400000002206, + "self_cpu_time_us": 54.411000000007334, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 1024 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 49.98300000001473, + "self_cpu_time_us": 39.710000000020955, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 1024 + ], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 10.272999999993772, + "self_cpu_time_us": 10.272999999993772, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cuLaunchKernel", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 81, + "cpu_time_us": 362.4449999999815, + "self_cpu_time_us": 362.4449999999815, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 4096, + 1024 + ], + [ + 4096 + ] + ], + "count": 24, + "cpu_time_us": 712.0160000000178, + "self_cpu_time_us": 71.53500000002168, + "cuda_time_us": 1965.5950000000012, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 1024 + ] + ], + "count": 24, + "cpu_time_us": 97.63299999999799, + "self_cpu_time_us": 42.94500000000335, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 1024 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 54.687999999994645, + "self_cpu_time_us": 44.329000000034284, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 1024 + ], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 10.35899999996036, + "self_cpu_time_us": 10.35899999996036, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 8.709999999984575, + "self_cpu_time_us": 8.709999999984575, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 16, + 1024 + ], + [] + ], + "count": 24, + "cpu_time_us": 939.0039999999935, + "self_cpu_time_us": 64.38299999996525, + "cuda_time_us": 208.74600000000282, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 1024 + ] + ], + "count": 24, + "cpu_time_us": 95.11200000002646, + "self_cpu_time_us": 41.34000000003289, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 1024 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 53.77199999999357, + "self_cpu_time_us": 40.81200000000899, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 1024 + ], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 12.959999999984575, + "self_cpu_time_us": 12.959999999984575, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 1024, + 16 + ] + ], + "count": 24, + "cpu_time_us": 779.5090000000018, + "self_cpu_time_us": 43.53299999999581, + "cuda_time_us": 208.74600000000282, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 4096, + 16 + ], + [] + ], + "count": 24, + "cpu_time_us": 543.1629999999823, + "self_cpu_time_us": 49.80699999997887, + "cuda_time_us": 337.84699999999066, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 16 + ] + ], + "count": 25, + "cpu_time_us": 85.61099999999351, + "self_cpu_time_us": 34.93199999999342, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 16 + ], + [], + [] + ], + "count": 25, + "cpu_time_us": 50.67900000000009, + "self_cpu_time_us": 39.62000000001353, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 16 + ], + [], + [], + [] + ], + "count": 25, + "cpu_time_us": 11.058999999986554, + "self_cpu_time_us": 11.058999999986554, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 16, + 4096 + ] + ], + "count": 24, + "cpu_time_us": 411.45900000000984, + "self_cpu_time_us": 30.38800000002084, + "cuda_time_us": 337.84699999999066, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 881.2150000000038, + "self_cpu_time_us": 68.02200000002631, + "cuda_time_us": 488.58799999999974, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 813.1929999999775, + "self_cpu_time_us": 173.56600000002072, + "cuda_time_us": 488.58799999999974, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 1024, + 4096 + ], + [ + 1024 + ] + ], + "count": 24, + "cpu_time_us": 790.2489999999998, + "self_cpu_time_us": 69.83199999998033, + "cuda_time_us": 2146.819999999989, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 4096 + ] + ], + "count": 24, + "cpu_time_us": 95.59500000003027, + "self_cpu_time_us": 40.12900000002264, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 4096 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 55.466000000007625, + "self_cpu_time_us": 41.609000000025844, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 4096 + ], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 13.856999999981781, + "self_cpu_time_us": 13.856999999981781, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 5.369999999998981, + "self_cpu_time_us": 5.369999999998981, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 16, + 4096 + ], + [] + ], + "count": 24, + "cpu_time_us": 728.2660000000142, + "self_cpu_time_us": 86.21500000000378, + "cuda_time_us": 390.83400000000256, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 4096 + ] + ], + "count": 34, + "cpu_time_us": 125.25900000000183, + "self_cpu_time_us": 54.610000000011496, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 4096 + ], + [], + [] + ], + "count": 34, + "cpu_time_us": 70.64899999999034, + "self_cpu_time_us": 53.76900000002206, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 4096 + ], + [], + [], + [] + ], + "count": 34, + "cpu_time_us": 16.879999999968277, + "self_cpu_time_us": 16.879999999968277, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 4096, + 16 + ] + ], + "count": 24, + "cpu_time_us": 554.2030000000013, + "self_cpu_time_us": 31.3340000000062, + "cuda_time_us": 390.83400000000256, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 1024, + 16 + ], + [] + ], + "count": 24, + "cpu_time_us": 509.5710000000108, + "self_cpu_time_us": 45.95299999998679, + "cuda_time_us": 116.40399999999136, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 16 + ] + ], + "count": 40, + "cpu_time_us": 132.53299999995215, + "self_cpu_time_us": 55.514999999897555, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 16 + ], + [], + [] + ], + "count": 40, + "cpu_time_us": 77.0180000000546, + "self_cpu_time_us": 58.67200000007142, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 16 + ], + [], + [], + [] + ], + "count": 40, + "cpu_time_us": 18.345999999983178, + "self_cpu_time_us": 18.345999999983178, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 16, + 1024 + ] + ], + "count": 24, + "cpu_time_us": 384.78900000002614, + "self_cpu_time_us": 28.559000000026572, + "cuda_time_us": 116.40399999999136, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 4096, + 4096 + ], + [ + 4096 + ] + ], + "count": 1, + "cpu_time_us": 34.345000000001164, + "self_cpu_time_us": 2.2889999999970314, + "cuda_time_us": 93.59000000000378, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 4096 + ] + ], + "count": 1, + "cpu_time_us": 7.4320000000006985, + "self_cpu_time_us": 1.7079999999987194, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 4096 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 5.724000000001979, + "self_cpu_time_us": 5.298000000002503, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 4096 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.42599999999947613, + "self_cpu_time_us": 0.42599999999947613, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [], + [], + [], + [] + ], + "count": 3, + "cpu_time_us": 53.646999999997206, + "self_cpu_time_us": 4.193999999995867, + "cuda_time_us": 11.293000000005122, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 3, + "cpu_time_us": 49.45300000000134, + "self_cpu_time_us": 10.257000000005064, + "cuda_time_us": 11.293000000005122, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [], + [] + ], + "count": 2, + "cpu_time_us": 0.38699999999516876, + "self_cpu_time_us": 0.38699999999516876, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 16, + 4096 + ], + [] + ], + "count": 2, + "cpu_time_us": 57.27700000000186, + "self_cpu_time_us": 4.0310000000026776, + "cuda_time_us": 17.6929999999993, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 4096, + 16 + ] + ], + "count": 2, + "cpu_time_us": 46.046000000002095, + "self_cpu_time_us": 2.5900000000037835, + "cuda_time_us": 17.6929999999993, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 4096, + 16 + ], + [] + ], + "count": 1, + "cpu_time_us": 21.632999999994354, + "self_cpu_time_us": 1.9029999999984284, + "cuda_time_us": 4.8950000000040745, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 16, + 4096 + ] + ], + "count": 1, + "cpu_time_us": 16.015999999995984, + "self_cpu_time_us": 1.1449999999967986, + "cuda_time_us": 4.8950000000040745, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 2560, + 4096 + ], + [ + 2560 + ] + ], + "count": 1, + "cpu_time_us": 29.147000000004482, + "self_cpu_time_us": 2.290000000000873, + "cuda_time_us": 65.43299999999726, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 4096 + ] + ], + "count": 33, + "cpu_time_us": 185.2540000000081, + "self_cpu_time_us": 94.65600000003178, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 4096 + ], + [], + [] + ], + "count": 33, + "cpu_time_us": 90.59799999997631, + "self_cpu_time_us": 67.53799999999319, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 4096 + ], + [], + [], + [] + ], + "count": 33, + "cpu_time_us": 23.05999999998312, + "self_cpu_time_us": 23.05999999998312, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 2560, + 16 + ], + [] + ], + "count": 1, + "cpu_time_us": 21.293000000005122, + "self_cpu_time_us": 1.9100000000034925, + "cuda_time_us": 3.9360000000015134, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 16 + ] + ], + "count": 41, + "cpu_time_us": 134.22599999989325, + "self_cpu_time_us": 60.06499999989319, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 16 + ], + [], + [] + ], + "count": 41, + "cpu_time_us": 74.16100000000006, + "self_cpu_time_us": 58.07600000005186, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 16 + ], + [], + [], + [] + ], + "count": 41, + "cpu_time_us": 16.084999999948195, + "self_cpu_time_us": 16.084999999948195, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 16, + 2560 + ] + ], + "count": 1, + "cpu_time_us": 15.631999999997788, + "self_cpu_time_us": 1.1859999999942374, + "cuda_time_us": 3.9360000000015134, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 16.582000000002154, + "self_cpu_time_us": 1.2690000000002328, + "cuda_time_us": 1.951999999997497, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 15.31300000000192, + "self_cpu_time_us": 3.165000000008149, + "cuda_time_us": 1.951999999997497, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::split_with_sizes", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 5.488000000004831, + "self_cpu_time_us": 4.735000000007858, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 1.2929999999978463, + "self_cpu_time_us": 1.2929999999978463, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 6.050999999999476, + "self_cpu_time_us": 3.2449999999953434, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 2.8060000000041327, + "self_cpu_time_us": 2.2660000000032596, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.7479999999995925, + "self_cpu_time_us": 0.7479999999995925, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [], + [], + [] + ], + "count": 3, + "cpu_time_us": 64.17599999999948, + "self_cpu_time_us": 4.293000000005122, + "cuda_time_us": 6.527000000001863, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "count": 2, + "cpu_time_us": 8.633000000008906, + "self_cpu_time_us": 7.196000000010827, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 0.9219999999913853, + "self_cpu_time_us": 0.9219999999913853, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::detach", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [] + ], + "count": 1, + "cpu_time_us": 6.73399999999674, + "self_cpu_time_us": 2.466999999996915, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "detach", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [] + ], + "count": 1, + "cpu_time_us": 4.266999999999825, + "self_cpu_time_us": 4.266999999999825, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_is_all_true", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [] + ], + "count": 1, + "cpu_time_us": 27.653999999994994, + "self_cpu_time_us": 3.099999999991269, + "cuda_time_us": 1.0240000000048894, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::all", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [] + ], + "count": 1, + "cpu_time_us": 24.554000000003725, + "self_cpu_time_us": 9.425000000010186, + "cuda_time_us": 1.0240000000048894, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view_as", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 1, + "cpu_time_us": 3.1589999999996508, + "self_cpu_time_us": 2.0720000000001164, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 1, + "cpu_time_us": 1.0869999999995343, + "self_cpu_time_us": 1.0869999999995343, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::masked_scatter", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 1 + ], + [ + 300, + 2560 + ] + ], + "count": 1, + "cpu_time_us": 147.6640000000043, + "self_cpu_time_us": 25.54200000000128, + "cuda_time_us": 21.75800000000163, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 3.4099999999962165, + "self_cpu_time_us": 2.922999999995227, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.48700000000098953, + "self_cpu_time_us": 0.48700000000098953, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 1.9020000000018626, + "self_cpu_time_us": 1.3520000000062282, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.5499999999956344, + "self_cpu_time_us": 0.5499999999956344, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 2, + "cpu_time_us": 41.836999999999534, + "self_cpu_time_us": 5.863999999994121, + "cuda_time_us": 6.7189999999973224, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 12.14900000000489, + "self_cpu_time_us": 3.573000000011234, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::contiguous", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 1, + "cpu_time_us": 21.74199999999837, + "self_cpu_time_us": 1.389999999999418, + "cuda_time_us": 3.040000000000873, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::zeros", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [] + ], + "count": 49, + "cpu_time_us": 1086.6680000000997, + "self_cpu_time_us": 218.1570000001302, + "cuda_time_us": 63.125999999887426, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::zero_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456 + ] + ], + "count": 1, + "cpu_time_us": 15.25, + "self_cpu_time_us": 3.555000000000291, + "cuda_time_us": 0.9910000000018044, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::unbind", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [] + ], + "count": 1, + "cpu_time_us": 9.131000000001222, + "self_cpu_time_us": 4.453000000001339, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [], + [], + [], + [] + ], + "count": 3, + "cpu_time_us": 58.567999999992026, + "self_cpu_time_us": 4.225999999995111, + "cuda_time_us": 6.719999999993888, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 4, + "cpu_time_us": 78.45599999999831, + "self_cpu_time_us": 14.070999999996275, + "cuda_time_us": 8.319999999992433, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "count": 3, + "cpu_time_us": 11.705000000001746, + "self_cpu_time_us": 4.171000000009371, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [] + ], + "count": 3, + "cpu_time_us": 7.533999999992375, + "self_cpu_time_us": 5.781999999984691, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::set_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [ + 456, + 1 + ] + ], + "count": 3, + "cpu_time_us": 15.302000000003318, + "self_cpu_time_us": 15.302000000003318, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 1 + ], + [], + [] + ], + "count": 3, + "cpu_time_us": 7.036000000000058, + "self_cpu_time_us": 5.913000000000466, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 0.7030000000013388, + "self_cpu_time_us": 0.7030000000013388, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [] + ], + "count": 3, + "cpu_time_us": 6.400999999990745, + "self_cpu_time_us": 4.366999999991094, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 25.37399999999616, + "self_cpu_time_us": 1.2599999999947613, + "cuda_time_us": 1.5999999999985448, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 79 + ], + [] + ], + "count": 1, + "cpu_time_us": 2.5339999999996508, + "self_cpu_time_us": 2.5339999999996508, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 79 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 5.027000000001863, + "self_cpu_time_us": 4.353000000002794, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 79 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.6739999999990687, + "self_cpu_time_us": 0.6739999999990687, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [] + ], + "count": 5, + "cpu_time_us": 14.650999999998021, + "self_cpu_time_us": 12.485999999997148, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [], + [] + ], + "count": 5, + "cpu_time_us": 2.165000000000873, + "self_cpu_time_us": 2.165000000000873, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 1 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 3.327999999994063, + "self_cpu_time_us": 2.701999999997497, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 1 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.6259999999965657, + "self_cpu_time_us": 0.6259999999965657, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15 + ], + [] + ], + "count": 1, + "cpu_time_us": 0.9490000000005239, + "self_cpu_time_us": 0.9490000000005239, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 1 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 2.2839999999996508, + "self_cpu_time_us": 1.9140000000043074, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 1 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.3699999999953434, + "self_cpu_time_us": 0.3699999999953434, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 20 + ], + [] + ], + "count": 1, + "cpu_time_us": 0.6899999999950523, + "self_cpu_time_us": 0.6899999999950523, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 20 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 2.4619999999995343, + "self_cpu_time_us": 2.0169999999998254, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 20 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.44499999999970896, + "self_cpu_time_us": 0.44499999999970896, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 15, + 20 + ], + [] + ], + "count": 1, + "cpu_time_us": 0.9159999999974389, + "self_cpu_time_us": 0.9159999999974389, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 15, + 20 + ], + [] + ], + "count": 1, + "cpu_time_us": 2.800999999999476, + "self_cpu_time_us": 1.5560000000041327, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 15, + 20 + ], + [] + ], + "count": 1, + "cpu_time_us": 1.2449999999953434, + "self_cpu_time_us": 1.2449999999953434, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 300 + ], + [], + [] + ], + "count": 2, + "cpu_time_us": 7.050999999999476, + "self_cpu_time_us": 5.821000000003551, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 300 + ], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 1.2299999999959255, + "self_cpu_time_us": 1.2299999999959255, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300 + ], + [ + 300 + ], + [] + ], + "count": 1, + "cpu_time_us": 1.1089999999967404, + "self_cpu_time_us": 1.1089999999967404, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::is_nonzero", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [] + ], + "count": 3, + "cpu_time_us": 50.13500000000204, + "self_cpu_time_us": 5.455999999998312, + "cuda_time_us": 3.00800000000163, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 77 + ], + [] + ], + "count": 1, + "cpu_time_us": 1.525999999998021, + "self_cpu_time_us": 1.525999999998021, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 77 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 3.1299999999973807, + "self_cpu_time_us": 2.504000000000815, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 77 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.6259999999965657, + "self_cpu_time_us": 0.6259999999965657, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 456 + ], + [] + ], + "count": 1, + "cpu_time_us": 2.786999999996624, + "self_cpu_time_us": 1.5419999999940046, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 456 + ], + [] + ], + "count": 1, + "cpu_time_us": 1.2450000000026193, + "self_cpu_time_us": 1.2450000000026193, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 456 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.5439999999944121, + "self_cpu_time_us": 0.5439999999944121, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 2.9789999999993597, + "self_cpu_time_us": 2.5129999999990105, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456 + ], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 1.004000000000815, + "self_cpu_time_us": 1.004000000000815, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::index_put_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 456 + ], + [], + [ + 3, + 456 + ], + [] + ], + "count": 1, + "cpu_time_us": 102.24600000000646, + "self_cpu_time_us": 6.746000000006461, + "cuda_time_us": 8.47899999999936, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 456 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.5559999999968568, + "self_cpu_time_us": 0.5559999999968568, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 1, + "cpu_time_us": 4.569999999999709, + "self_cpu_time_us": 3.8849999999947613, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cua.language", + "device_type": "DeviceType.CPU", + "is_user_annotation": true, + "input_shapes": [], + "count": 1, + "cpu_time_us": 182429.199, + "self_cpu_time_us": 44744.38799999867, + "cuda_time_us": 64797.982999999535, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ], + [] + ], + "count": 1, + "cpu_time_us": 4.581000000005588, + "self_cpu_time_us": 4.038000000007742, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.5429999999978463, + "self_cpu_time_us": 0.5429999999978463, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32 + ], + [] + ], + "count": 1, + "cpu_time_us": 3.0800000000017462, + "self_cpu_time_us": 2.6999999999970896, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.3800000000046566, + "self_cpu_time_us": 0.3800000000046566, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 32 + ], + [] + ], + "count": 1, + "cpu_time_us": 2.654999999998836, + "self_cpu_time_us": 2.0159999999959837, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 32 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.6390000000028522, + "self_cpu_time_us": 0.6390000000028522, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 32, + 1 + ], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.47599999999511056, + "self_cpu_time_us": 0.47599999999511056, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 32, + 1 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 5.521999999997206, + "self_cpu_time_us": 4.317000000002736, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 32, + 1 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 1.2049999999944703, + "self_cpu_time_us": 1.2049999999944703, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456 + ], + [] + ], + "count": 1, + "cpu_time_us": 2.447999999996682, + "self_cpu_time_us": 1.9099999999962165, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 21.32499999999709, + "self_cpu_time_us": 1.569999999999709, + "cuda_time_us": 2.175999999999476, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 19.75499999999738, + "self_cpu_time_us": 4.082999999998719, + "cuda_time_us": 2.175999999999476, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.38799999999901047, + "self_cpu_time_us": 0.38799999999901047, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [ + 3, + 1, + 1, + 456 + ] + ], + "count": 1, + "cpu_time_us": 302.69199999999546, + "self_cpu_time_us": 16.04799999998795, + "cuda_time_us": 1.5679999999993015, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 3.338000000003376, + "self_cpu_time_us": 2.6920000000027358, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.6460000000006403, + "self_cpu_time_us": 0.6460000000006403, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [] + ], + "count": 1, + "cpu_time_us": 8.029999999998836, + "self_cpu_time_us": 5.406999999999243, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 2.6229999999995925, + "self_cpu_time_us": 2.6229999999995925, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 3.176999999996042, + "self_cpu_time_us": 2.3299999999944703, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.8470000000015716, + "self_cpu_time_us": 0.8470000000015716, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [] + ], + "count": 1, + "cpu_time_us": 3.2180000000007567, + "self_cpu_time_us": 1.1920000000027358, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [] + ], + "count": 1, + "cpu_time_us": 2.025999999998021, + "self_cpu_time_us": 2.025999999998021, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::bmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 32, + 1 + ], + [ + 3, + 1, + 456 + ] + ], + "count": 1, + "cpu_time_us": 266.62400000000343, + "self_cpu_time_us": 41.27200000000448, + "cuda_time_us": 1.5679999999993015, + "self_cuda_time_us": 0.0 + }, + { + "op": "cuLaunchKernelEx", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 1, + "cpu_time_us": 8.626999999993131, + "self_cpu_time_us": 8.626999999993131, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 32, + 456 + ], + [] + ], + "count": 1, + "cpu_time_us": 2.257000000005064, + "self_cpu_time_us": 2.257000000005064, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 456 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 5.9429999999993015, + "self_cpu_time_us": 4.788999999997031, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 456 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 1.15400000000227, + "self_cpu_time_us": 1.15400000000227, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456, + 32 + ], + [], + [] + ], + "count": 6, + "cpu_time_us": 20.41700000000128, + "self_cpu_time_us": 17.02499999999418, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456, + 32 + ], + [], + [], + [] + ], + "count": 6, + "cpu_time_us": 3.3920000000071013, + "self_cpu_time_us": 3.3920000000071013, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 24.427000000003318, + "self_cpu_time_us": 20.68800000000192, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [], + [] + ], + "count": 56, + "cpu_time_us": 31.07699999995384, + "self_cpu_time_us": 31.07699999995384, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 64 + ], + [], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 40.153999999994994, + "self_cpu_time_us": 4.917999999997846, + "cuda_time_us": 2.2080000000059954, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 64 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 2, + "cpu_time_us": 35.23599999999715, + "self_cpu_time_us": 7.719999999993888, + "cuda_time_us": 2.2080000000059954, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [], + [] + ], + "count": 258, + "cpu_time_us": 3521.902000000031, + "self_cpu_time_us": 290.1460000000443, + "cuda_time_us": 756.1709999999221, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 258, + "cpu_time_us": 4278.422999999879, + "self_cpu_time_us": 922.8479999997217, + "cuda_time_us": 920.0259999998962, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::result_type", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 65, + "cpu_time_us": 23.43700000012177, + "self_cpu_time_us": 23.43700000012177, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560 + ], + [], + [], + [], + [] + ], + "count": 65, + "cpu_time_us": 1307.697000000051, + "self_cpu_time_us": 135.43000000025495, + "cuda_time_us": 160.52500000000146, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 65, + "cpu_time_us": 1172.266999999796, + "self_cpu_time_us": 323.13899999972637, + "cuda_time_us": 160.52500000000146, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::type_as", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 2560 + ] + ], + "count": 65, + "cpu_time_us": 1292.3650000000343, + "self_cpu_time_us": 140.38099999995757, + "cuda_time_us": 163.8549999999741, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 65, + "cpu_time_us": 1151.9840000000768, + "self_cpu_time_us": 105.31700000018463, + "cuda_time_us": 163.8549999999741, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 8192, + 2560 + ], + [] + ], + "count": 32, + "cpu_time_us": 1222.2819999999774, + "self_cpu_time_us": 72.67399999999907, + "cuda_time_us": 4636.71300000004, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 2560 + ] + ], + "count": 32, + "cpu_time_us": 148.09099999993487, + "self_cpu_time_us": 62.687999999994645, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 2560 + ], + [], + [] + ], + "count": 32, + "cpu_time_us": 85.40299999994022, + "self_cpu_time_us": 63.09899999987829, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 2560 + ], + [], + [], + [] + ], + "count": 32, + "cpu_time_us": 22.304000000061933, + "self_cpu_time_us": 22.304000000061933, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 8192 + ] + ], + "count": 32, + "cpu_time_us": 1001.5170000000435, + "self_cpu_time_us": 158.10599999986152, + "cuda_time_us": 4636.71300000004, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 273, + "cpu_time_us": 618.1050000001342, + "self_cpu_time_us": 341.8220000000292, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 273, + "cpu_time_us": 276.28300000010495, + "self_cpu_time_us": 276.28300000010495, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 8192 + ], + [] + ], + "count": 40, + "cpu_time_us": 30.228000000075554, + "self_cpu_time_us": 30.228000000075554, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 92.98400000001857, + "self_cpu_time_us": 74.02100000006612, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [], + [], + [] + ], + "count": 96, + "cpu_time_us": 53.76599999994505, + "self_cpu_time_us": 53.76599999994505, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 4096, + 2560 + ], + [] + ], + "count": 24, + "cpu_time_us": 693.0169999999416, + "self_cpu_time_us": 45.42100000008213, + "cuda_time_us": 1907.6529999999839, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 2560 + ] + ], + "count": 24, + "cpu_time_us": 87.53999999994267, + "self_cpu_time_us": 37.76599999989412, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 2560 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 49.774000000048545, + "self_cpu_time_us": 39.36599999993632, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 2560 + ], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 10.408000000112224, + "self_cpu_time_us": 10.408000000112224, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 4096 + ] + ], + "count": 24, + "cpu_time_us": 560.0559999999168, + "self_cpu_time_us": 96.23499999981868, + "cuda_time_us": 1907.6529999999839, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 4096 + ], + [] + ], + "count": 24, + "cpu_time_us": 17.851000000053318, + "self_cpu_time_us": 17.851000000053318, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [] + ], + "count": 88, + "cpu_time_us": 229.86399999986315, + "self_cpu_time_us": 130.57399999980407, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [] + ], + "count": 64, + "cpu_time_us": 80.46900000007736, + "self_cpu_time_us": 80.46900000007736, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 32, + 2560 + ], + [] + ], + "count": 48, + "cpu_time_us": 1867.696000000069, + "self_cpu_time_us": 103.23600000015722, + "cuda_time_us": 257.3740000000107, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32, + 2560 + ] + ], + "count": 48, + "cpu_time_us": 169.97600000000966, + "self_cpu_time_us": 75.58799999995244, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32, + 2560 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 94.38800000005722, + "self_cpu_time_us": 67.99000000012165, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32, + 2560 + ], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 26.397999999935564, + "self_cpu_time_us": 26.397999999935564, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 32 + ] + ], + "count": 48, + "cpu_time_us": 1594.4839999999022, + "self_cpu_time_us": 212.1849999999322, + "cuda_time_us": 257.3740000000107, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 32 + ], + [] + ], + "count": 48, + "cpu_time_us": 30.131000000052154, + "self_cpu_time_us": 30.131000000052154, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::zero_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 4 + ] + ], + "count": 24, + "cpu_time_us": 353.5089999999909, + "self_cpu_time_us": 75.73900000001595, + "cuda_time_us": 22.363999999950465, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 238.70199999992474, + "self_cpu_time_us": 207.6899999999805, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [], + [], + [] + ], + "count": 96, + "cpu_time_us": 65.00499999981548, + "self_cpu_time_us": 65.00499999981548, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::squeeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 1, + 4 + ], + [] + ], + "count": 24, + "cpu_time_us": 138.95899999999529, + "self_cpu_time_us": 120.17699999999604, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 1, + 4 + ], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 32.05500000000029, + "self_cpu_time_us": 32.05500000000029, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 22.95300000005227, + "self_cpu_time_us": 22.95300000005227, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 4 + ], + [] + ], + "count": 24, + "cpu_time_us": 105.15999999998894, + "self_cpu_time_us": 90.54699999998411, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 4 + ], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 14.613000000004831, + "self_cpu_time_us": 14.613000000004831, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::conv1d", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [ + 8192, + 1, + 4 + ], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 1909.5360000000146, + "self_cpu_time_us": 99.92800000002899, + "cuda_time_us": 2345.354999999996, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::convolution", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [ + 8192, + 1, + 4 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 1809.6079999999856, + "self_cpu_time_us": 145.0860000000248, + "cuda_time_us": 2345.354999999996, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_convolution", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [ + 8192, + 1, + 4 + ], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 1664.5219999999608, + "self_cpu_time_us": 414.3820000000196, + "cuda_time_us": 2345.354999999996, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::contiguous", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [] + ], + "count": 24, + "cpu_time_us": 538.9369999999617, + "self_cpu_time_us": 40.77099999998609, + "cuda_time_us": 1183.0289999999586, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [] + ], + "count": 24, + "cpu_time_us": 498.1659999999756, + "self_cpu_time_us": 89.3769999999713, + "cuda_time_us": 1183.0289999999586, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 165.3469999999943, + "self_cpu_time_us": 43.7399999999252, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [] + ], + "count": 24, + "cpu_time_us": 62.06099999993603, + "self_cpu_time_us": 44.867000000005646, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 1, + 4 + ], + [] + ], + "count": 24, + "cpu_time_us": 48.00100000001112, + "self_cpu_time_us": 34.72800000001007, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::squeeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 1, + 459 + ], + [] + ], + "count": 24, + "cpu_time_us": 63.45700000003853, + "self_cpu_time_us": 52.18899999994028, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 1, + 459 + ], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 11.268000000098255, + "self_cpu_time_us": 11.268000000098255, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 459 + ], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 97.67899999996735, + "self_cpu_time_us": 76.4509999999209, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 459 + ], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 21.22800000004645, + "self_cpu_time_us": 21.22800000004645, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 85.57900000004156, + "self_cpu_time_us": 68.7800000001007, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::split_with_sizes", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 205.1510000000053, + "self_cpu_time_us": 170.3480000000127, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2048 + ], + [] + ], + "count": 48, + "cpu_time_us": 248.48299999994197, + "self_cpu_time_us": 168.04599999990023, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2048 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 80.43700000004173, + "self_cpu_time_us": 80.43700000004173, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 18.820999999981723, + "self_cpu_time_us": 18.820999999981723, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 496.6289999999717, + "self_cpu_time_us": 36.541000000004715, + "cuda_time_us": 38.20400000005611, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 460.087999999967, + "self_cpu_time_us": 104.71100000000297, + "cuda_time_us": 38.20400000005611, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 436.4130000000223, + "self_cpu_time_us": 29.76100000005681, + "cuda_time_us": 51.25500000001921, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 406.6519999999655, + "self_cpu_time_us": 92.95700000008219, + "cuda_time_us": 51.25500000001921, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::repeat_interleave", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 128 + ], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 1888.7949999999983, + "self_cpu_time_us": 299.20799999993324, + "cuda_time_us": 1177.0490000000354, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 128 + ], + [] + ], + "count": 48, + "cpu_time_us": 186.2340000000113, + "self_cpu_time_us": 147.31300000014744, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 128 + ], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 38.92099999986385, + "self_cpu_time_us": 38.92099999986385, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 1, + 128 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 191.19400000011228, + "self_cpu_time_us": 161.50000000010914, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 1, + 128 + ], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 29.694000000003143, + "self_cpu_time_us": 29.694000000003143, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 2, + 128 + ], + [] + ], + "count": 48, + "cpu_time_us": 1049.4439999999013, + "self_cpu_time_us": 304.8199999998469, + "cuda_time_us": 1177.0490000000354, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 2, + 128 + ], + [], + [], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 281.0619999999835, + "self_cpu_time_us": 70.2299999999741, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::flatten", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 2, + 128 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 162.71500000004016, + "self_cpu_time_us": 86.20600000011473, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 2, + 128 + ], + [] + ], + "count": 48, + "cpu_time_us": 76.50899999992544, + "self_cpu_time_us": 76.50899999992544, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [], + [] + ], + "count": 72, + "cpu_time_us": 228.5089999998745, + "self_cpu_time_us": 179.34699999981967, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [], + [], + [] + ], + "count": 72, + "cpu_time_us": 49.16200000005483, + "self_cpu_time_us": 49.16200000005483, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [], + [], + [] + ], + "count": 72, + "cpu_time_us": 1308.8129999999219, + "self_cpu_time_us": 90.26199999982055, + "cuda_time_us": 617.947000000051, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 72, + "cpu_time_us": 1218.5510000001013, + "self_cpu_time_us": 227.88300000005256, + "cuda_time_us": 617.947000000051, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 144.09199999995326, + "self_cpu_time_us": 116.75400000000081, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456 + ], + [], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 440.1460000000152, + "self_cpu_time_us": 54.2949999999546, + "cuda_time_us": 58.617000000027474, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 385.8510000000606, + "self_cpu_time_us": 70.68600000005972, + "cuda_time_us": 58.617000000027474, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::pad", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [], + [] + ], + "count": 72, + "cpu_time_us": 2408.135000000024, + "self_cpu_time_us": 132.39399999981106, + "cuda_time_us": 718.9869999999646, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::constant_pad_nd", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [] + ], + "count": 72, + "cpu_time_us": 2275.741000000213, + "self_cpu_time_us": 451.40600000040286, + "cuda_time_us": 718.9869999999646, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [], + [], + [] + ], + "count": 72, + "cpu_time_us": 309.75599999990663, + "self_cpu_time_us": 131.82599999987724, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [], + [], + [], + [] + ], + "count": 96, + "cpu_time_us": 295.6230000000287, + "self_cpu_time_us": 229.00700000004144, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [], + [], + [] + ], + "count": 96, + "cpu_time_us": 66.61599999998725, + "self_cpu_time_us": 66.61599999998725, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::pad", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456 + ], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 1363.4360000000452, + "self_cpu_time_us": 59.167000000103144, + "cuda_time_us": 116.02600000010716, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::constant_pad_nd", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 1304.268999999942, + "self_cpu_time_us": 235.09499999989202, + "cuda_time_us": 116.02600000010716, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 159.83499999998457, + "self_cpu_time_us": 58.432000000022526, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 101.40299999996205, + "self_cpu_time_us": 76.24900000003254, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [], + [], + [] + ], + "count": 96, + "cpu_time_us": 53.095999999917694, + "self_cpu_time_us": 53.095999999917694, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [] + ], + "count": 48, + "cpu_time_us": 165.66000000001077, + "self_cpu_time_us": 137.71800000002258, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [] + ], + "count": 96, + "cpu_time_us": 252.90800000018498, + "self_cpu_time_us": 128.5370000003022, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [] + ], + "count": 96, + "cpu_time_us": 124.37099999988277, + "self_cpu_time_us": 124.37099999988277, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [] + ], + "count": 24, + "cpu_time_us": 58.336000000061176, + "self_cpu_time_us": 31.452000000077533, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [] + ], + "count": 24, + "cpu_time_us": 26.883999999983644, + "self_cpu_time_us": 26.883999999983644, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::ones", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 447.7970000000423, + "self_cpu_time_us": 89.54499999991094, + "cuda_time_us": 22.972999999932654, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 10.29599999999482, + "self_cpu_time_us": 10.29599999999482, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [] + ], + "count": 120, + "cpu_time_us": 389.68099999990227, + "self_cpu_time_us": 312.97699999975157, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [], + [], + [] + ], + "count": 168, + "cpu_time_us": 113.86000000027707, + "self_cpu_time_us": 113.86000000027707, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::masked_fill", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [ + 64, + 64 + ], + [] + ], + "count": 24, + "cpu_time_us": 1578.496999999923, + "self_cpu_time_us": 215.38800000002811, + "cuda_time_us": 181.48099999989063, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 74.22799999995914, + "self_cpu_time_us": 56.186999999968975, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [], + [], + [] + ], + "count": 264, + "cpu_time_us": 143.4719999998124, + "self_cpu_time_us": 143.4719999998124, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 64, + 64 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 127.52099999998609, + "self_cpu_time_us": 94.87799999990966, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 64, + 64 + ], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 32.64300000007643, + "self_cpu_time_us": 32.64300000007643, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [] + ], + "count": 24, + "cpu_time_us": 784.1120000000228, + "self_cpu_time_us": 132.0379999999859, + "cuda_time_us": 81.40099999999074, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 150.9939999999915, + "self_cpu_time_us": 43.474000000082015, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [] + ], + "count": 144, + "cpu_time_us": 373.08600000012666, + "self_cpu_time_us": 291.30700000005163, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [], + [] + ], + "count": 1152, + "cpu_time_us": 651.8250000008411, + "self_cpu_time_us": 651.8250000008411, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [ + 1, + 32, + 8, + 128, + 64 + ] + ], + "count": 48, + "cpu_time_us": 3703.3600000000006, + "self_cpu_time_us": 534.5030000000843, + "cuda_time_us": 1301.5180000000255, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 222.1109999999535, + "self_cpu_time_us": 196.40599999983533, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "count": 72, + "cpu_time_us": 737.3789999999717, + "self_cpu_time_us": 172.80399999988003, + "cuda_time_us": 541.4129999999714, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "count": 48, + "cpu_time_us": 61.13400000011461, + "self_cpu_time_us": 61.13400000011461, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 122.8210000000181, + "self_cpu_time_us": 97.29500000002008, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 25.52599999999802, + "self_cpu_time_us": 25.52599999999802, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [] + ], + "count": 48, + "cpu_time_us": 211.27699999993638, + "self_cpu_time_us": 151.8149999999514, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 59.46199999998498, + "self_cpu_time_us": 59.46199999998498, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 256, + 64, + 64 + ], + [] + ], + "count": 48, + "cpu_time_us": 52.20100000005914, + "self_cpu_time_us": 52.20100000005914, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 101.8769999999131, + "self_cpu_time_us": 75.09200000002602, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 200.71599999999307, + "self_cpu_time_us": 101.61200000011013, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 99.10399999988294, + "self_cpu_time_us": 99.10399999988294, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::arange", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [], + [], + [] + ], + "count": 96, + "cpu_time_us": 1706.4560000001293, + "self_cpu_time_us": 256.3210000003528, + "cuda_time_us": 89.2719999999099, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::zero_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ] + ], + "count": 48, + "cpu_time_us": 565.2499999999491, + "self_cpu_time_us": 136.12199999997392, + "cuda_time_us": 80.18199999991339, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::zeros_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 487.14000000002125, + "self_cpu_time_us": 62.52099999997881, + "cuda_time_us": 108.97900000006484, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 348.46500000016385, + "self_cpu_time_us": 106.72600000014063, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::zero_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ] + ], + "count": 24, + "cpu_time_us": 234.18000000000757, + "self_cpu_time_us": 56.867000000100234, + "cuda_time_us": 108.97900000006484, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 144.2960000000312, + "self_cpu_time_us": 121.11899999996967, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 133.26299999998446, + "self_cpu_time_us": 119.28399999991962, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8 + ], + [] + ], + "count": 24, + "cpu_time_us": 67.08300000004965, + "self_cpu_time_us": 55.47000000003027, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8 + ], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 11.613000000019383, + "self_cpu_time_us": 11.613000000019383, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 1 + ], + [] + ], + "count": 24, + "cpu_time_us": 61.559999999917636, + "self_cpu_time_us": 48.59099999992759, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 1 + ], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 12.968999999990046, + "self_cpu_time_us": 12.968999999990046, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [] + ], + "count": 960, + "cpu_time_us": 2881.814999999966, + "self_cpu_time_us": 2337.473999999318, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [ + 1, + 32, + 128, + 128 + ] + ], + "count": 384, + "cpu_time_us": 17428.446999999855, + "self_cpu_time_us": 3678.4310000008772, + "cuda_time_us": 5150.859000000011, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [], + [] + ], + "count": 768, + "cpu_time_us": 2032.832999999744, + "self_cpu_time_us": 1650.4069999997955, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [], + [], + [] + ], + "count": 960, + "cpu_time_us": 520.5329999997775, + "self_cpu_time_us": 520.5329999997775, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [] + ], + "count": 768, + "cpu_time_us": 1933.9380000001256, + "self_cpu_time_us": 1303.6739999999554, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [], + [] + ], + "count": 768, + "cpu_time_us": 630.2640000001702, + "self_cpu_time_us": 630.2640000001702, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [], + [] + ], + "count": 384, + "cpu_time_us": 1019.4279999998253, + "self_cpu_time_us": 861.6539999998204, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 157.7740000000049, + "self_cpu_time_us": 157.7740000000049, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [] + ], + "count": 384, + "cpu_time_us": 798.7549999998155, + "self_cpu_time_us": 448.96099999982107, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [] + ], + "count": 384, + "cpu_time_us": 349.7939999999944, + "self_cpu_time_us": 349.7939999999944, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32, + 64, + 128 + ], + [] + ], + "count": 576, + "cpu_time_us": 380.83499999954074, + "self_cpu_time_us": 380.83499999954074, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 688.8199999999924, + "self_cpu_time_us": 590.1740000000573, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 64 + ], + [ + 1, + 32, + 64, + 128 + ] + ], + "count": 192, + "cpu_time_us": 8267.823999999993, + "self_cpu_time_us": 1668.4190000000235, + "cuda_time_us": 1727.1810000000842, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 64 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 623.4180000001506, + "self_cpu_time_us": 502.42400000036287, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 64 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 120.99399999978777, + "self_cpu_time_us": 120.99399999978777, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 64 + ], + [] + ], + "count": 192, + "cpu_time_us": 499.1809999999241, + "self_cpu_time_us": 344.45100000000093, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 64 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 154.72999999992317, + "self_cpu_time_us": 154.72999999992317, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 1, + 1 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 573.3200000000652, + "self_cpu_time_us": 462.65399999967485, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 1, + 1 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 110.66600000039034, + "self_cpu_time_us": 110.66600000039034, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 617.3809999998484, + "self_cpu_time_us": 479.27400000001944, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 64 + ], + [ + 1, + 32, + 64, + 128 + ] + ], + "count": 192, + "cpu_time_us": 8440.843000000023, + "self_cpu_time_us": 1629.5399999998626, + "cuda_time_us": 1677.4350000002014, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 64 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 586.3869999999442, + "self_cpu_time_us": 474.8260000000446, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 64 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 111.56099999989965, + "self_cpu_time_us": 111.56099999989965, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 64 + ], + [] + ], + "count": 192, + "cpu_time_us": 509.01000000024214, + "self_cpu_time_us": 345.22199999970326, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 64 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 163.7880000005389, + "self_cpu_time_us": 163.7880000005389, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32, + 128, + 128 + ], + [] + ], + "count": 192, + "cpu_time_us": 124.0430000002525, + "self_cpu_time_us": 124.0430000002525, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "count": 24, + "cpu_time_us": 487.38599999998405, + "self_cpu_time_us": 99.54599999992934, + "cuda_time_us": 541.4129999999714, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "count": 24, + "cpu_time_us": 16.054999999993015, + "self_cpu_time_us": 16.054999999993015, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 72.52500000000873, + "self_cpu_time_us": 57.788999999989755, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 14.736000000018976, + "self_cpu_time_us": 14.736000000018976, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 556.5200000000477, + "self_cpu_time_us": 78.60500000008324, + "cuda_time_us": 122.22300000002724, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 477.9149999999645, + "self_cpu_time_us": 118.11099999994622, + "cuda_time_us": 122.22300000002724, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::zeros_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 625.8269999999175, + "self_cpu_time_us": 153.7509999999893, + "cuda_time_us": 40.41099999997823, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 173.3739999999816, + "self_cpu_time_us": 56.618000000016764, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [] + ], + "count": 48, + "cpu_time_us": 150.75100000006205, + "self_cpu_time_us": 75.0410000000702, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [] + ], + "count": 48, + "cpu_time_us": 75.70999999999185, + "self_cpu_time_us": 75.70999999999185, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [], + [], + [], + [] + ], + "count": 120, + "cpu_time_us": 1810.5229999999574, + "self_cpu_time_us": 140.9719999999361, + "cuda_time_us": 523.8799999999901, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 96, + "cpu_time_us": 1669.5510000000213, + "self_cpu_time_us": 370.873000000036, + "cuda_time_us": 523.8799999999901, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::result_type", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [] + ], + "count": 24, + "cpu_time_us": 16.38000000003376, + "self_cpu_time_us": 16.38000000003376, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [] + ], + "count": 24, + "cpu_time_us": 80.78200000003562, + "self_cpu_time_us": 40.33000000008906, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [] + ], + "count": 24, + "cpu_time_us": 40.451999999946565, + "self_cpu_time_us": 40.451999999946565, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 2560, + 4096 + ], + [] + ], + "count": 32, + "cpu_time_us": 1940.6020000000426, + "self_cpu_time_us": 101.02900000009686, + "cuda_time_us": 3003.4649999999237, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 4096, + 2560 + ] + ], + "count": 32, + "cpu_time_us": 1658.0069999999396, + "self_cpu_time_us": 211.16199999999662, + "cuda_time_us": 3003.4649999999237, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [] + ], + "count": 104, + "cpu_time_us": 76.61300000002666, + "self_cpu_time_us": 76.61300000002666, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 9216, + 2560 + ], + [] + ], + "count": 64, + "cpu_time_us": 2682.42899999996, + "self_cpu_time_us": 177.3420000000915, + "cuda_time_us": 11053.05100000005, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 9216, + 2560 + ] + ], + "count": 64, + "cpu_time_us": 363.55799999997544, + "self_cpu_time_us": 120.66500000006636, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 9216, + 2560 + ], + [], + [] + ], + "count": 64, + "cpu_time_us": 242.89299999990908, + "self_cpu_time_us": 197.24099999996542, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 9216, + 2560 + ], + [], + [], + [] + ], + "count": 64, + "cpu_time_us": 45.651999999943655, + "self_cpu_time_us": 45.651999999943655, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 9216 + ] + ], + "count": 64, + "cpu_time_us": 2141.528999999893, + "self_cpu_time_us": 313.2739999997284, + "cuda_time_us": 11053.05100000005, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 9216 + ], + [] + ], + "count": 128, + "cpu_time_us": 89.9179999998305, + "self_cpu_time_us": 89.9179999998305, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [] + ], + "count": 88, + "cpu_time_us": 27.8190000000468, + "self_cpu_time_us": 27.8190000000468, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 16, + 2560 + ], + [] + ], + "count": 88, + "cpu_time_us": 3324.7280000000173, + "self_cpu_time_us": 175.34599999971397, + "cuda_time_us": 736.1450000001205, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 2560 + ] + ], + "count": 88, + "cpu_time_us": 359.4170000002341, + "self_cpu_time_us": 136.76100000021688, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 2560 + ], + [], + [] + ], + "count": 88, + "cpu_time_us": 222.65600000001723, + "self_cpu_time_us": 177.23900000029244, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 2560 + ], + [], + [], + [] + ], + "count": 88, + "cpu_time_us": 45.416999999724794, + "self_cpu_time_us": 45.416999999724794, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 16 + ] + ], + "count": 88, + "cpu_time_us": 2789.9650000000693, + "self_cpu_time_us": 396.74600000004284, + "cuda_time_us": 736.1450000001205, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 16 + ], + [] + ], + "count": 128, + "cpu_time_us": 90.0520000000979, + "self_cpu_time_us": 90.0520000000979, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 9216, + 16 + ], + [] + ], + "count": 64, + "cpu_time_us": 1821.1359999998967, + "self_cpu_time_us": 124.10200000002806, + "cuda_time_us": 828.5429999999615, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 9216, + 16 + ] + ], + "count": 64, + "cpu_time_us": 228.93400000008114, + "self_cpu_time_us": 91.99300000007497, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 9216, + 16 + ], + [], + [] + ], + "count": 64, + "cpu_time_us": 136.94100000000617, + "self_cpu_time_us": 104.99200000002747, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 9216, + 16 + ], + [], + [], + [] + ], + "count": 64, + "cpu_time_us": 31.948999999978696, + "self_cpu_time_us": 31.948999999978696, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 16, + 9216 + ] + ], + "count": 64, + "cpu_time_us": 1468.0999999997875, + "self_cpu_time_us": 288.50600000013947, + "cuda_time_us": 828.5429999999615, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [] + ], + "count": 128, + "cpu_time_us": 266.3909999999596, + "self_cpu_time_us": 164.41199999999662, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [] + ], + "count": 128, + "cpu_time_us": 101.97899999996298, + "self_cpu_time_us": 101.97899999996298, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [], + [], + [], + [] + ], + "count": 96, + "cpu_time_us": 1703.426999999967, + "self_cpu_time_us": 132.64599999990605, + "cuda_time_us": 778.4330000000773, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 96, + "cpu_time_us": 1570.7810000000609, + "self_cpu_time_us": 333.2380000000121, + "cuda_time_us": 778.4330000000773, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 2560, + 9216 + ], + [] + ], + "count": 32, + "cpu_time_us": 1137.2649999999703, + "self_cpu_time_us": 62.83399999991525, + "cuda_time_us": 5381.458000000028, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 9216 + ] + ], + "count": 32, + "cpu_time_us": 129.84399999999732, + "self_cpu_time_us": 52.10299999991548, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 9216 + ], + [], + [] + ], + "count": 32, + "cpu_time_us": 77.74100000008184, + "self_cpu_time_us": 58.34100000002945, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 9216 + ], + [], + [], + [] + ], + "count": 32, + "cpu_time_us": 19.400000000052387, + "self_cpu_time_us": 19.400000000052387, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 9216, + 2560 + ] + ], + "count": 32, + "cpu_time_us": 944.5870000000577, + "self_cpu_time_us": 136.27599999998347, + "cuda_time_us": 5381.458000000028, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [] + ], + "count": 64, + "cpu_time_us": 136.98600000003353, + "self_cpu_time_us": 82.71700000004785, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [] + ], + "count": 64, + "cpu_time_us": 54.26899999998568, + "self_cpu_time_us": 54.26899999998568, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [], + [] + ], + "count": 32, + "cpu_time_us": 6.244999999864376, + "self_cpu_time_us": 6.244999999864376, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 16, + 9216 + ], + [] + ], + "count": 32, + "cpu_time_us": 1084.8129999999364, + "self_cpu_time_us": 59.455999999903725, + "cuda_time_us": 480.7109999998356, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 9216 + ] + ], + "count": 32, + "cpu_time_us": 112.48499999995693, + "self_cpu_time_us": 48.5789999999688, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 9216 + ], + [], + [] + ], + "count": 32, + "cpu_time_us": 63.905999999988126, + "self_cpu_time_us": 46.839000000065425, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 9216 + ], + [], + [], + [] + ], + "count": 32, + "cpu_time_us": 17.0669999999227, + "self_cpu_time_us": 17.0669999999227, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 9216, + 16 + ] + ], + "count": 32, + "cpu_time_us": 912.8720000000758, + "self_cpu_time_us": 133.129999999961, + "cuda_time_us": 480.7109999998356, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 2560, + 16 + ], + [] + ], + "count": 40, + "cpu_time_us": 1093.313999999984, + "self_cpu_time_us": 73.5540000001638, + "cuda_time_us": 196.7719999998517, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 16, + 2560 + ] + ], + "count": 40, + "cpu_time_us": 889.2849999999307, + "self_cpu_time_us": 160.89600000010978, + "cuda_time_us": 196.7719999998517, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 8192, + 16 + ], + [] + ], + "count": 8, + "cpu_time_us": 295.0759999999573, + "self_cpu_time_us": 14.555999999953201, + "cuda_time_us": 100.72500000002037, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 16 + ] + ], + "count": 8, + "cpu_time_us": 27.036999999952968, + "self_cpu_time_us": 10.936999999903492, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 16 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 16.100000000049477, + "self_cpu_time_us": 12.852000000042608, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 16 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 3.2480000000068685, + "self_cpu_time_us": 3.2480000000068685, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 16, + 8192 + ] + ], + "count": 8, + "cpu_time_us": 253.4830000000511, + "self_cpu_time_us": 31.261000000085915, + "cuda_time_us": 100.72500000002037, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 138.3359999999957, + "self_cpu_time_us": 10.603000000002794, + "cuda_time_us": 49.21000000003551, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 127.7329999999929, + "self_cpu_time_us": 27.438999999969383, + "cuda_time_us": 49.21000000003551, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [] + ], + "count": 8, + "cpu_time_us": 16.480999999999767, + "self_cpu_time_us": 16.480999999999767, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::chunk", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 512 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 157.89799999997194, + "self_cpu_time_us": 26.31799999998475, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::split", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 512 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 131.5799999999872, + "self_cpu_time_us": 45.24799999996321, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 512 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 86.33200000002398, + "self_cpu_time_us": 37.119000000006054, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 512 + ], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 49.21300000001793, + "self_cpu_time_us": 34.29800000000978, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 512 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 14.915000000008149, + "self_cpu_time_us": 14.915000000008149, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 16, + "cpu_time_us": 255.6649999999936, + "self_cpu_time_us": 49.7889999999461, + "cuda_time_us": 37.79000000003725, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 16, + "cpu_time_us": 350.1230000000214, + "self_cpu_time_us": 65.97100000010687, + "cuda_time_us": 77.3700000000099, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 151.39899999997579, + "self_cpu_time_us": 47.04899999998452, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 8, + "cpu_time_us": 8.164000000004307, + "self_cpu_time_us": 8.164000000004307, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 16, + "cpu_time_us": 28.53000000004249, + "self_cpu_time_us": 28.53000000004249, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 183.57499999998254, + "self_cpu_time_us": 29.081999999965774, + "cuda_time_us": 55.64299999996729, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 276.9789999999921, + "self_cpu_time_us": 59.065999999977066, + "cuda_time_us": 85.62300000000687, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::result_type", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 8, + "cpu_time_us": 2.6499999999941792, + "self_cpu_time_us": 2.6499999999941792, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 256 + ], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 288.76599999991595, + "self_cpu_time_us": 20.154999999911524, + "cuda_time_us": 31.00199999997858, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 256 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 268.6110000000044, + "self_cpu_time_us": 55.45400000004156, + "cuda_time_us": 31.00199999997858, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::type_as", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [ + 1, + 456, + 16, + 256 + ] + ], + "count": 8, + "cpu_time_us": 148.1259999999893, + "self_cpu_time_us": 14.354000000006636, + "cuda_time_us": 29.98000000003958, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 133.77199999998265, + "self_cpu_time_us": 11.286000000007334, + "cuda_time_us": 29.98000000003958, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [] + ], + "count": 16, + "cpu_time_us": 53.91800000000512, + "self_cpu_time_us": 39.8140000001149, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 14.10399999989022, + "self_cpu_time_us": 14.10399999989022, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1024, + 2560 + ], + [] + ], + "count": 16, + "cpu_time_us": 582.150999999998, + "self_cpu_time_us": 46.58400000000256, + "cuda_time_us": 369.1410000000178, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 2560 + ] + ], + "count": 16, + "cpu_time_us": 60.16599999999744, + "self_cpu_time_us": 26.49399999997695, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 2560 + ], + [], + [] + ], + "count": 16, + "cpu_time_us": 33.67200000002049, + "self_cpu_time_us": 26.711999999984982, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 2560 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 6.960000000035507, + "self_cpu_time_us": 6.960000000035507, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 1024 + ] + ], + "count": 16, + "cpu_time_us": 475.400999999998, + "self_cpu_time_us": 94.81200000004901, + "cuda_time_us": 369.1410000000178, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 1024 + ], + [] + ], + "count": 32, + "cpu_time_us": 22.002999999953317, + "self_cpu_time_us": 22.002999999953317, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 1024, + 16 + ], + [] + ], + "count": 16, + "cpu_time_us": 543.8019999999524, + "self_cpu_time_us": 29.19100000000617, + "cuda_time_us": 546.1430000000255, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 16, + 1024 + ] + ], + "count": 16, + "cpu_time_us": 460.90699999999197, + "self_cpu_time_us": 64.18100000008417, + "cuda_time_us": 546.1430000000255, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 270.3259999999864, + "self_cpu_time_us": 20.769999999945867, + "cuda_time_us": 26.491000000038184, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 249.5560000000405, + "self_cpu_time_us": 52.65600000007544, + "cuda_time_us": 26.491000000038184, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [] + ], + "count": 16, + "cpu_time_us": 34.35700000006182, + "self_cpu_time_us": 34.35700000006182, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 140.3389999999781, + "self_cpu_time_us": 12.174999999944703, + "cuda_time_us": 21.02200000002631, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 255.7850000000035, + "self_cpu_time_us": 51.54800000008254, + "cuda_time_us": 34.0460000000312, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::result_type", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [] + ], + "count": 8, + "cpu_time_us": 2.1489999999612337, + "self_cpu_time_us": 2.1489999999612337, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::type_as", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [ + 1, + 456, + 4, + 256 + ] + ], + "count": 8, + "cpu_time_us": 151.26599999997416, + "self_cpu_time_us": 13.041999999972177, + "cuda_time_us": 13.02400000000489, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 138.22400000000198, + "self_cpu_time_us": 10.603000000031898, + "cuda_time_us": 13.02400000000489, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [] + ], + "count": 16, + "cpu_time_us": 56.23699999997916, + "self_cpu_time_us": 42.87699999997858, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 13.360000000000582, + "self_cpu_time_us": 13.360000000000582, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 64 + ], + [] + ], + "count": 16, + "cpu_time_us": 55.55000000000291, + "self_cpu_time_us": 45.65100000008533, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 64 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 9.898999999917578, + "self_cpu_time_us": 9.898999999917578, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 256 + ], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 72.15400000003865, + "self_cpu_time_us": 61.80600000001141, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 256 + ], + [], + [], + [] + ], + "count": 32, + "cpu_time_us": 20.88599999998405, + "self_cpu_time_us": 20.88599999998405, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 256 + ], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 41.608000000036554, + "self_cpu_time_us": 34.975000000107684, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 256 + ], + [], + [], + [] + ], + "count": 32, + "cpu_time_us": 13.798999999882653, + "self_cpu_time_us": 13.798999999882653, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 64 + ], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 44.77300000003015, + "self_cpu_time_us": 35.79599999997299, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 64 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 8.97700000005716, + "self_cpu_time_us": 8.97700000005716, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 64 + ], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 46.984000000040396, + "self_cpu_time_us": 39.55200000005425, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 64 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 7.431999999986147, + "self_cpu_time_us": 7.431999999986147, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ], + [], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 134.97400000000198, + "self_cpu_time_us": 20.234999999927823, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 114.73900000007416, + "self_cpu_time_us": 47.14200000005076, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::lift_fresh", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ] + ], + "count": 16, + "cpu_time_us": 3.408000000010361, + "self_cpu_time_us": 3.408000000010361, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ] + ], + "count": 16, + "cpu_time_us": 35.217000000033295, + "self_cpu_time_us": 23.45000000001164, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ] + ], + "count": 16, + "cpu_time_us": 11.767000000021653, + "self_cpu_time_us": 11.767000000021653, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::scaled_dot_product_attention", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 256 + ], + [ + 1, + 4, + 456, + 256 + ], + [ + 1, + 4, + 456, + 256 + ], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 815.5069999999978, + "self_cpu_time_us": 111.80400000000373, + "cuda_time_us": 356.8880000000063, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_scaled_dot_product_flash_attention", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 256 + ], + [ + 1, + 4, + 456, + 256 + ], + [ + 1, + 4, + 456, + 256 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 703.7029999999941, + "self_cpu_time_us": 82.3559999998979, + "cuda_time_us": 356.8880000000063, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 256 + ], + [], + [] + ], + "count": 16, + "cpu_time_us": 54.85499999998137, + "self_cpu_time_us": 44.317000000024564, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 256 + ], + [], + [] + ], + "count": 16, + "cpu_time_us": 30.51400000009744, + "self_cpu_time_us": 23.348000000143657, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::contiguous", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 8, + "cpu_time_us": 183.76299999999173, + "self_cpu_time_us": 14.840999999971245, + "cuda_time_us": 39.57999999997264, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 162.6600000000035, + "self_cpu_time_us": 12.153000000005704, + "cuda_time_us": 47.8349999999773, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 150.5069999999978, + "self_cpu_time_us": 32.89799999994284, + "cuda_time_us": 47.8349999999773, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 2.7730000000447035, + "self_cpu_time_us": 2.7730000000447035, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 16, + 4096 + ], + [] + ], + "count": 8, + "cpu_time_us": 315.33099999999104, + "self_cpu_time_us": 16.589999999996508, + "cuda_time_us": 74.16800000000512, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 4096, + 16 + ] + ], + "count": 8, + "cpu_time_us": 268.52999999999884, + "self_cpu_time_us": 35.742999999958556, + "cuda_time_us": 74.16800000000512, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ] + ], + "count": 1, + "cpu_time_us": 5.524000000004889, + "self_cpu_time_us": 5.524000000004889, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cua.output_projection", + "device_type": "DeviceType.CPU", + "is_user_annotation": true, + "input_shapes": [], + "count": 1, + "cpu_time_us": 116.00399999998626, + "self_cpu_time_us": 59.414999999979045, + "cuda_time_us": 4079.429999999993, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 248320, + 2560 + ], + [] + ], + "count": 1, + "cpu_time_us": 56.58900000000722, + "self_cpu_time_us": 2.794000000023516, + "cuda_time_us": 4079.429999999993, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320, + 2560 + ] + ], + "count": 1, + "cpu_time_us": 5.923999999999069, + "self_cpu_time_us": 2.3810000000230502, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320, + 2560 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 3.5429999999760184, + "self_cpu_time_us": 2.587999999988824, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 248320 + ] + ], + "count": 1, + "cpu_time_us": 47.87099999998463, + "self_cpu_time_us": 6.029999999969732, + "cuda_time_us": 4079.429999999993, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 248320 + ], + [] + ], + "count": 1, + "cpu_time_us": 1.0830000000132713, + "self_cpu_time_us": 1.0830000000132713, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cua.readout", + "device_type": "DeviceType.CPU", + "is_user_annotation": true, + "input_shapes": [], + "count": 1, + "cpu_time_us": 4262.532999999996, + "self_cpu_time_us": 195.24399999991874, + "cuda_time_us": 7.22999999995227, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 248320 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 6.217000000004191, + "self_cpu_time_us": 5.38300000000163, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 248320 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.8340000000025611, + "self_cpu_time_us": 0.8340000000025611, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 248320 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 3.7850000000034925, + "self_cpu_time_us": 2.8699999999953434, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 248320 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.9150000000081491, + "self_cpu_time_us": 0.9150000000081491, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 3, + "cpu_time_us": 3984.0160000000033, + "self_cpu_time_us": 11.864000000001397, + "cuda_time_us": 3.551999999996042, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::lift_fresh", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ] + ], + "count": 1, + "cpu_time_us": 0.18900000001303852, + "self_cpu_time_us": 0.18900000001303852, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ] + ], + "count": 1, + "cpu_time_us": 2.504000000015367, + "self_cpu_time_us": 1.430000000022119, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ] + ], + "count": 1, + "cpu_time_us": 1.073999999993248, + "self_cpu_time_us": 1.073999999993248, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320 + ], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 0.5969999999797437, + "self_cpu_time_us": 0.5969999999797437, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [] + ], + "count": 1, + "cpu_time_us": 1.970999999990454, + "self_cpu_time_us": 1.187000000005355, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 21.46700000000419, + "self_cpu_time_us": 1.8429999999934807, + "cuda_time_us": 1.6640000000188593, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::softmax", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [] + ], + "count": 1, + "cpu_time_us": 24.144000000000233, + "self_cpu_time_us": 3.6750000000174623, + "cuda_time_us": 1.150999999983469, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::resolve_conj", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ] + ], + "count": 1, + "cpu_time_us": 0.40000000002328306, + "self_cpu_time_us": 0.40000000002328306, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ] + ], + "count": 1, + "cpu_time_us": 0.2440000000060536, + "self_cpu_time_us": 0.2440000000060536, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 1, + "cpu_time_us": 30.437999999994645, + "self_cpu_time_us": 1.5069999999832362, + "cuda_time_us": 1.5359999999927823, + "self_cuda_time_us": 0.0 + }, + { + "op": "cudaDeviceSynchronize", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 9.3519999999844, + "self_cpu_time_us": 9.3519999999844, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + } + ] + } + }, + { + "id": "640x480-short-q8", + "size": [ + 640, + 480 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 8, + "status": "complete", + "fixture_sha256": "038faab1159fdf610cb0c828b6c9e7cb12ee95a82539b9639f283530c99b5bf7", + "questions_metadata": [ + { + "question": "q1", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q2", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q3", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q4", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q5", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q6", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q7", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + }, + { + "question": "q8", + "input_tokens": 456, + "goal_tokens": 6, + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + } + ], + "input_tokens": 3648, + "profile": { + "trace": "640x480-short-q8.trace.json", + "trace_sha256": "7411ccb692ad007ca9a12265a95556f71553e723eeb14f3883bfa378635f32d5", + "trace_bytes": 229296929, + "instrumentation_exact_parity": true, + "modules": { + "vision": "base_model.model.model.visual", + "language": "base_model.model.model.language_model", + "output_projection": "base_model.model.lm_head" + }, + "request_count": 1, + "uninstrumented_reference_requests": 1, + "forward_count": 8, + "stage_counts": { + "prepare": 8, + "transfer": 8, + "forward": 8, + "vision": 8, + "language": 8, + "output_projection": 8, + "readout": 8 + }, + "timing_note": "Count invocations from CPU user annotations only. CPU and CUDA rows with the same name are distinct views, not additional invocations; do not add their durations. Inclusive nested ranges overlap. CUDA fields are raw profiler aggregates and may include synthetic annotations, not disjoint kernel time or wall time. Readout starts after root forward; transfer covers inputs.to().", + "operators": [ + { + "op": "cua.language", + "device_type": "DeviceType.CUDA", + "is_user_annotation": true, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1471376.678, + "self_cuda_time_us": 1471376.678 + }, + { + "op": "cua.forward", + "device_type": "DeviceType.CUDA", + "is_user_annotation": true, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 308469.851, + "self_cuda_time_us": 308469.851 + }, + { + "op": "cua.vision", + "device_type": "DeviceType.CUDA", + "is_user_annotation": true, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 289773.6170000001, + "self_cuda_time_us": 289773.6170000001 + }, + { + "op": "ampere_bf16_s1688gemm_bf16_64x128_sliced1x2_ldg8_f2f_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 768, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 136135.0529999987, + "self_cuda_time_us": 136135.0529999987 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 9216 + ] + ], + "count": 512, + "cpu_time_us": 12965.169999999824, + "self_cpu_time_us": 8030.567999999155, + "cuda_time_us": 91341.24299999687, + "self_cuda_time_us": 91341.24299999687 + }, + { + "op": "ampere_bf16_s1688gemm_bf16_128x128_ldg8_f2f_stages_32x1_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 448, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 52769.79499999821, + "self_cuda_time_us": 52769.79499999821 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 9216 + ], + [ + 9216, + 2560 + ] + ], + "count": 256, + "cpu_time_us": 5802.8770000015065, + "self_cpu_time_us": 3520.018000001728, + "cuda_time_us": 45215.69199999863, + "self_cuda_time_us": 45215.69199999863 + }, + { + "op": "aten::bmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32, + 64, + 128 + ], + [ + 32, + 128, + 128 + ] + ], + "count": 3072, + "cpu_time_us": 72434.38899999888, + "self_cpu_time_us": 58297.09000000209, + "cuda_time_us": 38231.32100000439, + "self_cuda_time_us": 38231.32100000439 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 8192 + ] + ], + "count": 256, + "cpu_time_us": 8060.586000001043, + "self_cpu_time_us": 4378.086000003212, + "cuda_time_us": 37075.57599999878, + "self_cuda_time_us": 37075.57599999878 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 248320 + ] + ], + "count": 8, + "cpu_time_us": 295.17700000019977, + "self_cpu_time_us": 205.64600000000792, + "cuda_time_us": 35722.330000000075, + "self_cuda_time_us": 35722.330000000075 + }, + { + "op": "ampere_bf16_s16816gemm_bf16_128x64_ldg8_f2f_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 35722.330000000075, + "self_cuda_time_us": 35722.330000000075 + }, + { + "op": "cua.output_projection", + "device_type": "DeviceType.CUDA", + "is_user_annotation": true, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 35722.330000000075, + "self_cuda_time_us": 35722.330000000075 + }, + { + "op": "ampere_bf16_s1688gemm_bf16_128x64_sliced1x2_ldg8_relu_f2f_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 400, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 31686.310999998663, + "self_cuda_time_us": 31686.310999998663 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 5344, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 24745.87300000021, + "self_cuda_time_us": 24745.87300000021 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 4096 + ], + [ + 4096, + 2560 + ] + ], + "count": 256, + "cpu_time_us": 10630.208999998416, + "self_cpu_time_us": 6814.200999996596, + "cuda_time_us": 22939.256000000212, + "self_cuda_time_us": 22939.256000000212 + }, + { + "op": "aten::linalg_solve_triangular", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 36129.46199999994, + "self_cpu_time_us": 8843.297000003047, + "cuda_time_us": 26807.565999998245, + "self_cuda_time_us": 22849.08299999869 + }, + { + "op": "void batch_trsm_left_kernel(cublasTrsmBatchParams2, float, float const*, int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 384, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 22849.08299999869, + "self_cuda_time_us": 22849.08299999869 + }, + { + "op": "ampere_bf16_s1688gemm_bf16_64x64_sliced1x4_ldg8_f2f_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 256, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 22813.89600000037, + "self_cuda_time_us": 22813.89600000037 + }, + { + "op": "ampere_sgemm_128x128_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1920, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 22281.55399999766, + "self_cuda_time_us": 22281.55399999766 + }, + { + "op": "void at::native::unrolled_elementwise_kernel, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1> >(int, at::native::CUDAFunctor_add, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1424, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 20251.87799999905, + "self_cuda_time_us": 20251.87799999905 + }, + { + "op": "ampere_sgemm_128x128_nn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1536, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 19409.016000003, + "self_cuda_time_us": 19409.016000003 + }, + { + "op": "ampere_sgemm_128x128_nt", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1536, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 18822.30500000139, + "self_cuda_time_us": 18822.30500000139 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#12}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#12}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 896, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 18658.64700000141, + "self_cuda_time_us": 18658.64700000141 + }, + { + "op": "void at::native::unrolled_elementwise_kernel, 4, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1> >(int, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 3464, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 16263.141999999396, + "self_cuda_time_us": 16263.141999999396 + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024 + ], + [ + 1200, + 4096 + ], + [ + 4096, + 1024 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 4930.42199999938, + "self_cpu_time_us": 3184.4670000005426, + "cuda_time_us": 15736.064000000653, + "self_cuda_time_us": 15736.064000000653 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 4096 + ] + ], + "count": 192, + "cpu_time_us": 5203.997000000512, + "self_cpu_time_us": 2269.2889999993495, + "cuda_time_us": 15694.21899999943, + "self_cuda_time_us": 15694.21899999943 + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096 + ], + [ + 1200, + 1024 + ], + [ + 1024, + 4096 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 4358.670000001366, + "self_cpu_time_us": 3267.5239999985934, + "cuda_time_us": 14826.538999999219, + "self_cuda_time_us": 14826.538999999219 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 3104, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 14502.604999997391, + "self_cuda_time_us": 14502.604999997391 + }, + { + "op": "aten::_flash_attention_forward", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [ + 1, + 1200, + 16, + 64 + ], + [ + 1, + 1200, + 16, + 64 + ], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 8787.740999998583, + "self_cpu_time_us": 2952.410999998043, + "cuda_time_us": 14417.785999999513, + "self_cuda_time_us": 14417.785999999513 + }, + { + "op": "void pytorch_flash::flash_fwd_kernel >, false, false, false, false, false, true, false, false>(pytorch_flash::Flash_fwd_params)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 14417.785999999513, + "self_cuda_time_us": 14417.785999999513 + }, + { + "op": "aten::bmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32, + 64, + 64 + ], + [ + 32, + 64, + 128 + ] + ], + "count": 1536, + "cpu_time_us": 33539.306000003955, + "self_cpu_time_us": 26760.405000005077, + "cuda_time_us": 12909.12599999897, + "self_cuda_time_us": 12909.12599999897 + }, + { + "op": "ampere_sgemm_32x32_sliced1x4_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1424, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 12594.51199999702, + "self_cuda_time_us": 12594.51199999702 + }, + { + "op": "aten::bmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32, + 128, + 64 + ], + [ + 32, + 64, + 128 + ] + ], + "count": 1536, + "cpu_time_us": 36033.52600000212, + "self_cpu_time_us": 28937.261000000493, + "cuda_time_us": 12406.341999998258, + "self_cuda_time_us": 12406.341999998258 + }, + { + "op": "ampere_sgemm_128x128_tt", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1536, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 12406.341999998258, + "self_cuda_time_us": 12406.341999998258 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::AUnaryFunctor >, std::array, false>(int, at::native::AUnaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1664, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 11279.839999997886, + "self_cuda_time_us": 11279.839999997886 + }, + { + "op": "ampere_sgemm_128x32_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1232, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 11233.34099999693, + "self_cuda_time_us": 11233.34099999693 + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3072 + ], + [ + 1200, + 1024 + ], + [ + 1024, + 3072 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 4213.53100000057, + "self_cpu_time_us": 3150.0300000016287, + "cuda_time_us": 10775.203000000198, + "self_cuda_time_us": 10775.203000000198 + }, + { + "op": "ampere_bf16_s1688gemm_bf16_128x128_ldg8_relu_f2f_stages_32x1_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 10775.203000000198, + "self_cuda_time_us": 10775.203000000198 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::bfloat16_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda(float)#1}, std::array, false>(int, at::native::bfloat16_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 2872, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 10489.391999989079, + "self_cuda_time_us": 10489.391999989079 + }, + { + "op": "aten::bmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 256, + 64, + 128 + ], + [ + 256, + 128, + 64 + ] + ], + "count": 384, + "cpu_time_us": 18813.891999999352, + "self_cpu_time_us": 16741.51300000114, + "cuda_time_us": 9372.42799999869, + "self_cuda_time_us": 9372.42799999869 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 1, + 456, + 9216 + ], + [] + ], + "count": 512, + "cpu_time_us": 6057.717000000426, + "self_cpu_time_us": 3681.104000000414, + "cuda_time_us": 9325.956000000035, + "self_cuda_time_us": 9325.956000000035 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [ + 1, + 8192, + 456 + ], + [] + ], + "count": 192, + "cpu_time_us": 1987.5670000021346, + "self_cpu_time_us": 1040.0160000022734, + "cuda_time_us": 8855.387999998784, + "self_cuda_time_us": 8855.387999998784 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 2, + 128 + ], + [ + 1, + 456, + 16, + 2, + 128 + ], + [] + ], + "count": 384, + "cpu_time_us": 3752.891999997126, + "self_cpu_time_us": 1997.6379999966593, + "cuda_time_us": 8780.33300000077, + "self_cuda_time_us": 8780.33300000077 + }, + { + "op": "aten::_conv_depthwise2d", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 1, + 456 + ], + [ + 8192, + 1, + 1, + 4 + ], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 4350.840000001102, + "self_cpu_time_us": 1781.8680000031745, + "cuda_time_us": 8755.63100000161, + "self_cuda_time_us": 8755.63100000161 + }, + { + "op": "void at::native::(anonymous namespace)::conv_depthwise2d_forward_kernel_generic(torch::headeronly::detail::GenericPackedTensorAccessor, c10::BFloat16 const, 3ul, torch::headeronly::DefaultPtrTraits, int>, at::detail::IndexBoundsCheck<4ul, int>, c10::BFloat16 const, 4ul, torch::headeronly::DefaultPtrTraits, int>, torch::headeronly::detail::GenericPackedTensorAccessor, c10::BFloat16, 3ul, torch::headeronly::DefaultPtrTraits, int>, at::detail::IndexBoundsCheck<4ul, int>, c10::BFloat16, 4ul, torch::headeronly::DefaultPtrTraits, int>, torch::headeronly::detail::GenericPackedTensorAccessor, c10::BFloat16 const, 3ul, torch::headeronly::DefaultPtrTraits, int>, at::detail::IndexBoundsCheck<4ul, int>, c10::BFloat16 const, 4ul, torch::headeronly::DefaultPtrTraits, int>, torch::headeronly::detail::GenericPackedTensorAccessor, c10::BFloat16 const, 0ul, torch::headeronly::DefaultPtrTraits, int>, at::detail::IndexBoundsCheck<1ul, int>, c10::BFloat16 const, 1ul, torch::headeronly::DefaultPtrTraits, int>, bool, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 8755.63100000161, + "self_cuda_time_us": 8755.63100000161 + }, + { + "op": "cua.transfer", + "device_type": "DeviceType.CUDA", + "is_user_annotation": true, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 8500.038999999902, + "self_cuda_time_us": 8500.038999999902 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::CUDAFunctor_add, std::array, false>(int, at::native::CUDAFunctor_add, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 3472, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 7662.878999994908, + "self_cuda_time_us": 7662.878999994908 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [ + 1, + 32, + 456, + 128 + ], + [] + ], + "count": 1152, + "cpu_time_us": 10822.440000002869, + "self_cpu_time_us": 5723.920000004815, + "cuda_time_us": 7475.372999999454, + "self_cuda_time_us": 7475.372999999454 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1216, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 7393.326000001456, + "self_cuda_time_us": 7393.326000001456 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "count": 576, + "cpu_time_us": 5768.982999999527, + "self_cpu_time_us": 3143.5839999992895, + "cuda_time_us": 7319.276000000216, + "self_cuda_time_us": 7319.276000000216 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 2080, + "cpu_time_us": 18801.02600000183, + "self_cpu_time_us": 9361.277000004586, + "cuda_time_us": 7122.529999992999, + "self_cuda_time_us": 7122.529999992999 + }, + { + "op": "aten::cudnn_convolution", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3, + 2, + 16, + 16 + ], + [ + 1024, + 3, + 2, + 16, + 16 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 1090.070000000007, + "self_cpu_time_us": 721.2530000000261, + "cuda_time_us": 6687.289999999586, + "self_cuda_time_us": 6687.289999999586 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [ + 1, + 32, + 8, + 64, + 1 + ] + ], + "count": 576, + "cpu_time_us": 7361.571000000142, + "self_cpu_time_us": 4725.878999999259, + "cuda_time_us": 6533.428999999305, + "self_cuda_time_us": 6533.428999999305 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 16 + ], + [ + 16, + 9216 + ] + ], + "count": 512, + "cpu_time_us": 8216.444000000134, + "self_cpu_time_us": 5967.155000002982, + "cuda_time_us": 6404.582999999548, + "self_cuda_time_us": 6404.582999999548 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1536 + ], + [ + 1200, + 1536 + ], + [] + ], + "count": 16, + "cpu_time_us": 7610.433999999819, + "self_cpu_time_us": 119.33499999959895, + "cuda_time_us": 6327.781000000177, + "self_cuda_time_us": 6327.781000000177 + }, + { + "op": "Memcpy HtoD (Pageable -> Device)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 64, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 6283.236999999353, + "self_cuda_time_us": 6283.236999999353 + }, + { + "op": "sm80_xmma_fprop_implicit_gemm_indexed_bf16bf16_bf16f32_f32_nhwckrsc_nhwc_tilesize128x256x32_stage3_warpsize2x4x1_g1_tensor16x8x16_execute_kernel__5x_cudnn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 6277.927999999825, + "self_cuda_time_us": 6277.927999999825 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 1, + 456, + 9216 + ], + [] + ], + "count": 768, + "cpu_time_us": 6845.56099999907, + "self_cpu_time_us": 3445.7269999967684, + "cuda_time_us": 6107.255999999368, + "self_cuda_time_us": 6107.255999999368 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 1200, + 4096 + ], + [] + ], + "count": 192, + "cpu_time_us": 2392.926000000778, + "self_cpu_time_us": 1469.0650000008027, + "cuda_time_us": 5853.891999999323, + "self_cuda_time_us": 5853.891999999323 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1920, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 5753.607000003394, + "self_cuda_time_us": 5753.607000003394 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 16 + ] + ], + "count": 704, + "cpu_time_us": 17200.572000000742, + "self_cpu_time_us": 10621.29700000293, + "cuda_time_us": 5687.058999997476, + "self_cuda_time_us": 5687.058999997476 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [] + ], + "count": 512, + "cpu_time_us": 6823.832999999635, + "self_cpu_time_us": 4473.958999997354, + "cuda_time_us": 5011.719999997615, + "self_cuda_time_us": 5011.719999997615 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 832, + "cpu_time_us": 9907.070999996897, + "self_cpu_time_us": 6137.494999995179, + "cuda_time_us": 4867.830000002097, + "self_cuda_time_us": 4867.830000002097 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [ + 1, + 32, + 64, + 128 + ], + [] + ], + "count": 1536, + "cpu_time_us": 18943.040999995414, + "self_cpu_time_us": 12330.378999993438, + "cuda_time_us": 4813.638000004183, + "self_cuda_time_us": 4813.638000004183 + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024 + ], + [ + 1200, + 1024 + ], + [ + 1024, + 1024 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 7126.294999999955, + "self_cpu_time_us": 5044.378000001205, + "cuda_time_us": 4498.1020000008575, + "self_cuda_time_us": 4498.1020000008575 + }, + { + "op": "void cutlass::Kernel2(cutlass_80_tensorop_bf16_s16816gemm_relu_bf16_64x64_32x6_tn_align8::Params)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 4406.500000000437, + "self_cuda_time_us": 4406.500000000437 + }, + { + "op": "aten::cat", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 1056, + "cpu_time_us": 17271.55699999645, + "self_cpu_time_us": 9988.42199999893, + "cuda_time_us": 4211.546000000759, + "self_cuda_time_us": 4211.546000000759 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::CUDAFunctor_add, std::array, false>(int, at::native::CUDAFunctor_add, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 904, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 4158.211000002091, + "self_cuda_time_us": 4158.211000002091 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::FillFunctor, std::array, false>(int, at::native::FillFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1536, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 4098.128999996232, + "self_cuda_time_us": 4098.128999996232 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 16 + ], + [ + 16, + 1024 + ] + ], + "count": 128, + "cpu_time_us": 2904.8699999988603, + "self_cpu_time_us": 1634.820999998643, + "cuda_time_us": 4055.833000000028, + "self_cuda_time_us": 4055.833000000028 + }, + { + "op": "ampere_sgemm_64x64_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 128, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 4004.6929999984714, + "self_cuda_time_us": 4004.6929999984714 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::BinaryFunctor >, std::array, false>(int, at::native::BinaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 320, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3977.4509999984875, + "self_cuda_time_us": 3977.4509999984875 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [ + 1, + 32, + 1, + 1 + ] + ], + "count": 1536, + "cpu_time_us": 18084.647000002704, + "self_cpu_time_us": 11551.259000000093, + "cuda_time_us": 3954.6860000004963, + "self_cuda_time_us": 3954.6860000004963 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [ + 14592, + 128 + ], + [] + ], + "count": 768, + "cpu_time_us": 7303.1860000019515, + "self_cpu_time_us": 3655.926000001098, + "cuda_time_us": 3940.564999998125, + "self_cuda_time_us": 3940.564999998125 + }, + { + "op": "void at::native::reduce_kernel<512, 1, at::native::ReduceOp, unsigned int, float, 4, 4> >(at::native::ReduceOp, unsigned int, float, 4, 4>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 840, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3912.9939999979833, + "self_cuda_time_us": 3912.9939999979833 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 1, + 456, + 9216 + ] + ], + "count": 256, + "cpu_time_us": 3097.7399999995396, + "self_cpu_time_us": 1913.4819999994943, + "cuda_time_us": 3749.5049999991606, + "self_cuda_time_us": 3749.5049999991606 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 9216 + ], + [ + 9216, + 16 + ] + ], + "count": 256, + "cpu_time_us": 5499.807999999277, + "self_cpu_time_us": 3318.0909999979194, + "cuda_time_us": 3680.546999999351, + "self_cuda_time_us": 3680.546999999351 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [ + 1, + 32, + 64, + 128 + ], + [] + ], + "count": 1536, + "cpu_time_us": 17148.994000000836, + "self_cpu_time_us": 8595.820000000545, + "cuda_time_us": 3644.7929999996704, + "self_cuda_time_us": 3644.7929999996704 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 1200, + 4096 + ], + [] + ], + "count": 384, + "cpu_time_us": 3577.252999999735, + "self_cpu_time_us": 1817.4079999993846, + "cuda_time_us": 3623.8999999991356, + "self_cuda_time_us": 3623.8999999991356 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [ + 1200, + 1, + 64 + ] + ], + "count": 768, + "cpu_time_us": 9084.118999999206, + "self_cpu_time_us": 5692.829999998648, + "cuda_time_us": 3620.050999999454, + "self_cuda_time_us": 3620.050999999454 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [ + 1, + 32, + 128, + 128 + ], + [] + ], + "count": 1536, + "cpu_time_us": 16943.12099999581, + "self_cpu_time_us": 10571.040999996185, + "cuda_time_us": 3477.7109999955865, + "self_cuda_time_us": 3477.7109999955865 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::BinaryFunctor >, std::array, false>(int, at::native::BinaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 768, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3377.266000003525, + "self_cuda_time_us": 3377.266000003525 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::pow_tensor_scalar_kernel_impl(at::TensorIteratorBase&, float)::{lambda(float)#1}, std::array, false>(int, at::native::(anonymous namespace)::pow_tensor_scalar_kernel_impl(at::TensorIteratorBase&, float)::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 840, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 3161.8440000001574, + "self_cuda_time_us": 3161.8440000001574 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 4096, + 16 + ] + ], + "count": 192, + "cpu_time_us": 4250.727999999421, + "self_cpu_time_us": 2564.560999998139, + "cuda_time_us": 2974.108999999051, + "self_cuda_time_us": 2974.108999999051 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [ + 1200, + 16, + 64 + ], + [] + ], + "count": 768, + "cpu_time_us": 7056.427000002674, + "self_cpu_time_us": 3678.1440000043367, + "cuda_time_us": 2942.563999998296, + "self_cuda_time_us": 2942.563999998296 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 1200, + 1024 + ], + [] + ], + "count": 584, + "cpu_time_us": 6831.681000001045, + "self_cpu_time_us": 4273.883000001908, + "cuda_time_us": 2856.980000001233, + "self_cuda_time_us": 2856.980000001233 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 1024 + ] + ], + "count": 128, + "cpu_time_us": 2614.56099999859, + "self_cpu_time_us": 1958.394999997763, + "cuda_time_us": 2686.95000000071, + "self_cuda_time_us": 2686.95000000071 + }, + { + "op": "ampere_bf16_s16816gemm_bf16_64x64_sliced1x2_ldg8_f2f_stages_64x5_tn", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 128, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2686.95000000071, + "self_cuda_time_us": 2686.95000000071 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [] + ], + "count": 192, + "cpu_time_us": 2984.377999999153, + "self_cpu_time_us": 2069.43399999768, + "cuda_time_us": 2672.5880000011966, + "self_cuda_time_us": 2672.5880000011966 + }, + { + "op": "aten::_flash_attention_forward", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [ + 1, + 456, + 4, + 256 + ], + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 64, + "cpu_time_us": 4425.865999999354, + "self_cpu_time_us": 1615.0950000006123, + "cuda_time_us": 2629.801000001331, + "self_cuda_time_us": 2629.801000001331 + }, + { + "op": "aten::mean", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [] + ], + "count": 520, + "cpu_time_us": 8593.355000002179, + "self_cpu_time_us": 6164.144000003871, + "cuda_time_us": 2534.9289999987377, + "self_cuda_time_us": 2534.9289999987377 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [ + 1, + 32, + 64, + 128 + ], + [] + ], + "count": 1536, + "cpu_time_us": 19330.04099999796, + "self_cpu_time_us": 10804.581999997521, + "cuda_time_us": 2429.8919999995414, + "self_cuda_time_us": 2429.8919999995414 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 16, + 4096 + ] + ], + "count": 192, + "cpu_time_us": 3039.2800000002753, + "self_cpu_time_us": 2222.3049999999057, + "cuda_time_us": 2419.377999999604, + "self_cuda_time_us": 2419.377999999604 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [] + ], + "count": 576, + "cpu_time_us": 4673.393000001917, + "self_cpu_time_us": 2273.628000001394, + "cuda_time_us": 2373.295999998765, + "self_cuda_time_us": 2373.295999998765 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [ + 1, + 32, + 512, + 1 + ] + ], + "count": 384, + "cpu_time_us": 4472.1079999984795, + "self_cpu_time_us": 2869.5660000004573, + "cuda_time_us": 2184.1369999997405, + "self_cuda_time_us": 2184.1369999997405 + }, + { + "op": "void pytorch_flash::flash_fwd_splitkv_kernel >, true, false, false, false, true, false, true, false>(pytorch_flash::Flash_fwd_params)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 64, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2180.4190000006492, + "self_cuda_time_us": 2180.4190000006492 + }, + { + "op": "void cublasLt::splitKreduce_kernel<32, 16, int, float, float, float, float, false, float, float, float, true, false, false, false>(cublasLt::cublasSplitKParams, float const*, float const*, float*, float*, float const*, float const*, float const*, float const*, float*, void*, long, float*, int*, float*, float*, float const*, float const*, float const*, float const*, float const*)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1424, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 2115.0839999976015, + "self_cuda_time_us": 2115.0839999976015 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560 + ] + ], + "count": 520, + "cpu_time_us": 5818.937999997404, + "self_cpu_time_us": 3673.4499999971595, + "cuda_time_us": 2097.9530000000086, + "self_cuda_time_us": 2097.9530000000086 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 1 + ] + ], + "count": 520, + "cpu_time_us": 6218.934999999445, + "self_cpu_time_us": 3959.933999998917, + "cuda_time_us": 2082.5049999992625, + "self_cuda_time_us": 2082.5049999992625 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [ + 1, + 32, + 456, + 1 + ] + ], + "count": 384, + "cpu_time_us": 4417.0020000027, + "self_cpu_time_us": 2811.239000005473, + "cuda_time_us": 1985.2050000009913, + "self_cuda_time_us": 1985.2050000009913 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 32 + ] + ], + "count": 384, + "cpu_time_us": 10182.245000001683, + "self_cpu_time_us": 6501.5910000007425, + "cuda_time_us": 1981.3919999953505, + "self_cuda_time_us": 1981.3919999953505 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::CUDAFunctorOnSelf_add, std::array, false>(int, at::native::CUDAFunctorOnSelf_add, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1872, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1949.498999999225, + "self_cuda_time_us": 1949.498999999225 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [ + 1, + 32, + 456, + 128 + ] + ], + "count": 384, + "cpu_time_us": 4553.590000001015, + "self_cpu_time_us": 2823.1800000040967, + "cuda_time_us": 1900.1610000034416, + "self_cuda_time_us": 1900.1610000034416 + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy, unsigned int, 3, 64, 64>(at::native::(anonymous namespace)::OpaqueType<4u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 64, 64>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 400, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1869.9870000008377, + "self_cuda_time_us": 1869.9870000008377 + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy, unsigned int, 4, 64, 64>(at::native::(anonymous namespace)::OpaqueType<2u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 64, 64>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 384, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1862.853999998857, + "self_cuda_time_us": 1862.853999998857 + }, + { + "op": "aten::sum", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 6369.9849999998405, + "self_cpu_time_us": 4507.0879999999015, + "cuda_time_us": 1816.7699999996985, + "self_cuda_time_us": 1816.7699999996985 + }, + { + "op": "void at::native::reduce_kernel<512, 1, at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(float, float)#1}>, unsigned int, float, 4, 4> >(at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(float, float)#1}>, unsigned int, float, 4, 4>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 384, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1816.7699999996985, + "self_cuda_time_us": 1816.7699999996985 + }, + { + "op": "aten::pow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 520, + "cpu_time_us": 8674.128000000652, + "self_cpu_time_us": 5978.75100000223, + "cuda_time_us": 1742.3540000009525, + "self_cuda_time_us": 1742.3540000009525 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [ + 1200, + 16, + 64 + ], + [] + ], + "count": 384, + "cpu_time_us": 4099.900999999896, + "self_cpu_time_us": 2518.138999999457, + "cuda_time_us": 1738.1289999996516, + "self_cuda_time_us": 1738.1289999996516 + }, + { + "op": "aten::native_layer_norm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [ + 1024 + ], + [ + 1024 + ], + [] + ], + "count": 392, + "cpu_time_us": 11828.05599999991, + "self_cpu_time_us": 5053.492000005703, + "cuda_time_us": 1737.8029999991122, + "self_cuda_time_us": 1737.8029999991122 + }, + { + "op": "void at::native::(anonymous namespace)::vectorized_layer_norm_kernel(int, float, c10::BFloat16 const*, c10::BFloat16 const*, c10::BFloat16 const*, float*, float*, c10::BFloat16*)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 392, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1737.8029999991122, + "self_cuda_time_us": 1737.8029999991122 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 1024, + 16 + ] + ], + "count": 192, + "cpu_time_us": 5790.376999998582, + "self_cpu_time_us": 3911.8929999973043, + "cuda_time_us": 1598.9739999996818, + "self_cuda_time_us": 1598.9739999996818 + }, + { + "op": "aten::silu", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ] + ], + "count": 256, + "cpu_time_us": 3452.9849999992875, + "self_cpu_time_us": 2177.4559999985067, + "cuda_time_us": 1565.1060000005673, + "self_cuda_time_us": 1565.1060000005673 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#6}::operator()() const::{lambda(c10::BFloat16)#1}, std::array, false>(int, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#6}::operator()() const::{lambda(c10::BFloat16)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 256, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1565.1060000005673, + "self_cuda_time_us": 1565.1060000005673 + }, + { + "op": "aten::silu", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ] + ], + "count": 192, + "cpu_time_us": 3070.3210000003164, + "self_cpu_time_us": 2017.1450000004988, + "cuda_time_us": 1541.2299999989627, + "self_cuda_time_us": 1541.2299999989627 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#6}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#6}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1541.2299999989627, + "self_cuda_time_us": 1541.2299999989627 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [ + 1, + 32, + 8, + 64, + 64 + ] + ], + "count": 384, + "cpu_time_us": 4901.122000000527, + "self_cpu_time_us": 3080.287000001248, + "cuda_time_us": 1477.1050000000832, + "self_cuda_time_us": 1477.1050000000832 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 448, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1476.5880000015895, + "self_cuda_time_us": 1476.5880000015895 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 16 + ], + [ + 16, + 2560 + ] + ], + "count": 320, + "cpu_time_us": 4850.460000001272, + "self_cpu_time_us": 3510.954000000929, + "cuda_time_us": 1476.288999998389, + "self_cuda_time_us": 1476.288999998389 + }, + { + "op": "Memcpy DtoD (Device -> Device)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 656, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1425.1420000025537, + "self_cuda_time_us": 1425.1420000025537 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::exp_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::exp_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 960, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1388.3149999972957, + "self_cuda_time_us": 1388.3149999972957 + }, + { + "op": "void cutlass::Kernel2(cutlass_80_wmma_tensorop_bf16_s161616gemm_bf16_32x32_64x1_tn_align8::Params)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 384, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1344.0229999975127, + "self_cuda_time_us": 1344.0229999975127 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [ + 14592, + 128 + ] + ], + "count": 192, + "cpu_time_us": 2417.7879999990546, + "self_cpu_time_us": 1456.2559999979567, + "cuda_time_us": 1342.6839999992226, + "self_cuda_time_us": 1342.6839999992226 + }, + { + "op": "void at::native::unrolled_elementwise_kernel >, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1> >(int, at::native::BinaryFunctor >, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1342.6839999992226, + "self_cuda_time_us": 1342.6839999992226 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::rsqrt_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::rsqrt_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1224, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1334.0900000033143, + "self_cuda_time_us": 1334.0900000033143 + }, + { + "op": "cua.readout", + "device_type": "DeviceType.CUDA", + "is_user_annotation": true, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1328.7109999997774, + "self_cuda_time_us": 1328.7109999997774 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 1200, + 1024 + ], + [] + ], + "count": 392, + "cpu_time_us": 3808.6290000020817, + "self_cpu_time_us": 1937.2410000020027, + "cuda_time_us": 1297.5050000019837, + "self_cuda_time_us": 1297.5050000019837 + }, + { + "op": "aten::gelu", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [] + ], + "count": 192, + "cpu_time_us": 2647.452000000965, + "self_cpu_time_us": 1719.268000001597, + "cuda_time_us": 1231.1149999999907, + "self_cuda_time_us": 1231.1149999999907 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::GeluCUDAKernelImpl(at::TensorIteratorBase&, at::native::GeluType)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array, false>(int, at::native::GeluCUDAKernelImpl(at::TensorIteratorBase&, at::native::GeluType)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1231.1149999999907, + "self_cuda_time_us": 1231.1149999999907 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 256, + "cpu_time_us": 2726.1390000007377, + "self_cpu_time_us": 1469.9990000016696, + "cuda_time_us": 1211.7010000004375, + "self_cuda_time_us": 1211.7010000004375 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560 + ], + [ + 2560 + ], + [] + ], + "count": 520, + "cpu_time_us": 4614.414000000077, + "self_cpu_time_us": 2275.201999997764, + "cuda_time_us": 1207.2710000000516, + "self_cuda_time_us": 1207.2710000000516 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 320, + "cpu_time_us": 4018.103000000032, + "self_cpu_time_us": 2610.2059999990597, + "cuda_time_us": 1062.5590000003285, + "self_cuda_time_us": 1062.5590000003285 + }, + { + "op": "aten::neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 32 + ] + ], + "count": 384, + "cpu_time_us": 4962.686999999627, + "self_cpu_time_us": 2909.769999996395, + "cuda_time_us": 1035.0470000010391, + "self_cuda_time_us": 1035.0470000010391 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 384, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 1035.0470000010391, + "self_cuda_time_us": 1035.0470000010391 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [ + 14592, + 1 + ] + ], + "count": 192, + "cpu_time_us": 2392.191999997711, + "self_cpu_time_us": 1560.2309999963618, + "cuda_time_us": 1000.0009999995964, + "self_cuda_time_us": 1000.0009999995964 + }, + { + "op": "aten::silu", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ] + ], + "count": 192, + "cpu_time_us": 2735.711999999112, + "self_cpu_time_us": 1784.6990000004735, + "cuda_time_us": 990.390999999916, + "self_cuda_time_us": 990.390999999916 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 990.390999999916, + "self_cuda_time_us": 990.390999999916 + }, + { + "op": "aten::pow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [] + ], + "count": 192, + "cpu_time_us": 4057.215000001481, + "self_cpu_time_us": 2849.2840000026044, + "cuda_time_us": 982.6469999991823, + "self_cuda_time_us": 982.6469999991823 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456 + ], + [ + 1, + 32, + 456 + ], + [] + ], + "count": 576, + "cpu_time_us": 4916.138000001636, + "self_cpu_time_us": 2567.022000001438, + "cuda_time_us": 975.6599999987811, + "self_cuda_time_us": 975.6599999987811 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [ + 1, + 456, + 8192 + ], + [] + ], + "count": 64, + "cpu_time_us": 744.1299999996263, + "self_cpu_time_us": 453.65200000036566, + "cuda_time_us": 966.3189999995666, + "self_cuda_time_us": 966.3189999995666 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [] + ], + "count": 192, + "cpu_time_us": 2370.985000001514, + "self_cpu_time_us": 1500.9710000033374, + "cuda_time_us": 938.0399999988149, + "self_cuda_time_us": 938.0399999988149 + }, + { + "op": "aten::mean", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 3998.2639999987005, + "self_cpu_time_us": 2981.4979999977513, + "cuda_time_us": 930.8189999998285, + "self_cuda_time_us": 930.8189999998285 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [ + 1, + 456, + 32, + 128 + ], + [] + ], + "count": 192, + "cpu_time_us": 2114.5910000004515, + "self_cpu_time_us": 1142.9980000009818, + "cuda_time_us": 906.689000000697, + "self_cuda_time_us": 906.689000000697 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::bfloat16_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda(float)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::bfloat16_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda(float)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 906.689000000697, + "self_cuda_time_us": 906.689000000697 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 128 + ], + [ + 14592, + 128 + ] + ], + "count": 192, + "cpu_time_us": 2523.3599999990256, + "self_cpu_time_us": 1627.3459999971092, + "cuda_time_us": 900.1700000003912, + "self_cuda_time_us": 900.1700000003912 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 16, + 1024 + ] + ], + "count": 192, + "cpu_time_us": 2869.035999999629, + "self_cpu_time_us": 2078.6739999990677, + "cuda_time_us": 867.5939999995026, + "self_cuda_time_us": 867.5939999995026 + }, + { + "op": "Memset (Device)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 1568, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 844.6649999996589, + "self_cuda_time_us": 844.6649999996589 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "count": 192, + "cpu_time_us": 1465.2639999994426, + "self_cpu_time_us": 665.1950000009238, + "cuda_time_us": 809.920000000202, + "self_cuda_time_us": 809.920000000202 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 16 + ], + [ + 16, + 8192 + ] + ], + "count": 64, + "cpu_time_us": 1612.1570000007923, + "self_cpu_time_us": 1250.4409999997006, + "cuda_time_us": 786.0240000011836, + "self_cuda_time_us": 786.0240000011836 + }, + { + "op": "void cutlass::Kernel2(cutlass_80_simt_sgemm_256x128_8x4_tn_align1::Params)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 64, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 786.0240000011836, + "self_cuda_time_us": 786.0240000011836 + }, + { + "op": "aten::masked_fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [ + 64, + 64 + ], + [] + ], + "count": 192, + "cpu_time_us": 3472.2550000006595, + "self_cpu_time_us": 1972.1820000005973, + "cuda_time_us": 753.2080000026617, + "self_cuda_time_us": 753.2080000026617 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::(anonymous namespace)::masked_fill_kernel(at::TensorIterator&, c10::Scalar const&)::{lambda()#1}::operator()() const::{lambda()#7}::operator()() const::{lambda(float, bool)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::(anonymous namespace)::masked_fill_kernel(at::TensorIterator&, c10::Scalar const&)::{lambda()#1}::operator()() const::{lambda()#7}::operator()() const::{lambda(float, bool)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 753.2080000026617, + "self_cuda_time_us": 753.2080000026617 + }, + { + "op": "aten::arange", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [ + 0 + ] + ], + "count": 856, + "cpu_time_us": 11019.154999997176, + "self_cpu_time_us": 4505.3239999982325, + "cuda_time_us": 726.4509999982838, + "self_cuda_time_us": 726.4509999982838 + }, + { + "op": "void (anonymous namespace)::elementwise_kernel_with_index(int, at::native::arange_cuda_out(c10::Scalar const&, c10::Scalar const&, c10::Scalar const&, at::Tensor&)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}, function_traits::result_type*)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 848, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 726.4509999982838, + "self_cuda_time_us": 726.4509999982838 + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096 + ], + [ + 300, + 4096 + ], + [ + 4096, + 4096 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 191.96799999990617, + "self_cpu_time_us": 124.86100000060105, + "cuda_time_us": 708.2089999999152, + "self_cuda_time_us": 708.2089999999152 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [] + ], + "count": 192, + "cpu_time_us": 2394.301000000516, + "self_cpu_time_us": 1563.2210000008781, + "cuda_time_us": 681.7860000007495, + "self_cuda_time_us": 681.7860000007495 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 1 + ], + [ + 1, + 32, + 8, + 1, + 64 + ], + [] + ], + "count": 192, + "cpu_time_us": 2985.50999999934, + "self_cpu_time_us": 2098.658999999243, + "cuda_time_us": 673.1769999985117, + "self_cuda_time_us": 673.1769999985117 + }, + { + "op": "void cublasLt::splitKreduce_kernel<32, 16, int, __nv_bfloat16, __nv_bfloat16, float, __nv_bfloat16, false, __nv_bfloat16, __nv_bfloat16, __nv_bfloat16, true, false, false, false>(cublasLt::cublasSplitKParams, __nv_bfloat16 const*, __nv_bfloat16 const*, __nv_bfloat16*, __nv_bfloat16*, float const*, float const*, __nv_bfloat16 const*, __nv_bfloat16 const*, __nv_bfloat16*, void*, long, float*, int*, float*, float*, float const*, float const*, float const*, float const*, float const*)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 384, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 637.3689999978378, + "self_cuda_time_us": 637.3689999978378 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 4096 + ], + [ + 4096, + 16 + ] + ], + "count": 64, + "cpu_time_us": 1704.2869999984105, + "self_cpu_time_us": 1098.779999998631, + "cuda_time_us": 630.8419999991602, + "self_cuda_time_us": 630.8419999991602 + }, + { + "op": "Memcpy DtoH (Device -> Pageable)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 616, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 603.4670000006736, + "self_cuda_time_us": 603.4670000006736 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [ + 1, + 32, + 8, + 64, + 64 + ], + [] + ], + "count": 192, + "cpu_time_us": 3991.8450000001612, + "self_cpu_time_us": 738.3019999988173, + "cuda_time_us": 602.3740000008547, + "self_cuda_time_us": 602.3740000008547 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 208, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 600.2280000002356, + "self_cuda_time_us": 600.2280000002356 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [ + 1 + ], + [] + ], + "count": 624, + "cpu_time_us": 10753.610000001063, + "self_cpu_time_us": 3022.9129999996803, + "cuda_time_us": 599.339000001055, + "self_cuda_time_us": 599.339000001055 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [] + ], + "count": 384, + "cpu_time_us": 3465.4449999994104, + "self_cpu_time_us": 1673.7370000007359, + "cuda_time_us": 597.5909999975993, + "self_cuda_time_us": 597.5909999975993 + }, + { + "op": "aten::exp", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ] + ], + "count": 576, + "cpu_time_us": 8529.942000000316, + "self_cpu_time_us": 4101.509999999049, + "cuda_time_us": 595.9059999986639, + "self_cuda_time_us": 595.9059999986639 + }, + { + "op": "aten::rsqrt", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1 + ] + ], + "count": 520, + "cpu_time_us": 5964.54000000043, + "self_cpu_time_us": 3675.7770000048477, + "cuda_time_us": 592.7149999989488, + "self_cuda_time_us": 592.7149999989488 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [] + ], + "count": 64, + "cpu_time_us": 839.190000000177, + "self_cpu_time_us": 541.3259999995644, + "cuda_time_us": 591.7379999995901, + "self_cuda_time_us": 591.7379999995901 + }, + { + "op": "aten::exp", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ] + ], + "count": 192, + "cpu_time_us": 2382.5260000022245, + "self_cpu_time_us": 1534.175000002244, + "cuda_time_us": 571.7049999982701, + "self_cuda_time_us": 571.7049999982701 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1 + ], + [], + [] + ], + "count": 520, + "cpu_time_us": 6491.0890000006475, + "self_cpu_time_us": 4285.863999999696, + "cuda_time_us": 570.0389999985055, + "self_cuda_time_us": 570.0389999985055 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [ + 32 + ], + [] + ], + "count": 192, + "cpu_time_us": 2954.395000001474, + "self_cpu_time_us": 2045.349999999802, + "cuda_time_us": 557.5440000002272, + "self_cuda_time_us": 557.5440000002272 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560 + ], + [], + [] + ], + "count": 520, + "cpu_time_us": 5907.666000001453, + "self_cpu_time_us": 3830.00700000544, + "cuda_time_us": 532.6910000002244, + "self_cuda_time_us": 532.6910000002244 + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560 + ], + [ + 300, + 4096 + ], + [ + 4096, + 2560 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 185.70399999998335, + "self_cpu_time_us": 121.46299999958137, + "cuda_time_us": 499.1120000000665, + "self_cuda_time_us": 499.1120000000665 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::sigmoid_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array, false>(int, at::native::sigmoid_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 256, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 478.8609999980108, + "self_cuda_time_us": 478.8609999980108 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [ + 1, + 456, + 1024 + ], + [] + ], + "count": 128, + "cpu_time_us": 1451.7210000002815, + "self_cpu_time_us": 878.0530000013823, + "cuda_time_us": 452.6579999990645, + "self_cuda_time_us": 452.6579999990645 + }, + { + "op": "void pytorch_flash::flash_fwd_splitkv_combine_kernel >, 4, 1, true>(pytorch_flash::Flash_fwd_params)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 64, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 449.3820000006817, + "self_cuda_time_us": 449.3820000006817 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 4 + ], + [ + 1, + 8192, + 4 + ], + [] + ], + "count": 192, + "cpu_time_us": 2559.1199999994424, + "self_cpu_time_us": 1540.7690000002622, + "cuda_time_us": 446.38700000187964, + "self_cuda_time_us": 446.38700000187964 + }, + { + "op": "aten::cumsum", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 3257.6490000015474, + "self_cpu_time_us": 2244.877000002147, + "cuda_time_us": 440.5929999982327, + "self_cuda_time_us": 440.5929999982327 + }, + { + "op": "void at::native::tensor_kernel_scan_innermost_dim >(float*, float const*, unsigned int, unsigned int, unsigned int, float, std::plus)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 440.5929999982327, + "self_cuda_time_us": 440.5929999982327 + }, + { + "op": "aten::rsqrt", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 1 + ] + ], + "count": 384, + "cpu_time_us": 4242.852999999028, + "self_cpu_time_us": 2604.9129999994475, + "cuda_time_us": 397.58300000152667, + "self_cuda_time_us": 397.58300000152667 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 1, + 456, + 4096 + ], + [] + ], + "count": 64, + "cpu_time_us": 689.8020000008983, + "self_cpu_time_us": 336.88100000139093, + "cuda_time_us": 392.36999999926775, + "self_cuda_time_us": 392.36999999926775 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 1 + ], + [], + [] + ], + "count": 384, + "cpu_time_us": 4693.116000002527, + "self_cpu_time_us": 3077.2800000007264, + "cuda_time_us": 386.80500000106986, + "self_cuda_time_us": 386.80500000106986 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [ + 1, + 456, + 32 + ], + [] + ], + "count": 192, + "cpu_time_us": 1654.113000000798, + "self_cpu_time_us": 820.2130000002508, + "cuda_time_us": 381.164999999688, + "self_cuda_time_us": 381.164999999688 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [ + 1, + 456, + 8192 + ], + [] + ], + "count": 64, + "cpu_time_us": 568.2569999998523, + "self_cpu_time_us": 289.0530000003055, + "cuda_time_us": 366.2319999998872, + "self_cuda_time_us": 366.2319999998872 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [ + 1, + 32, + 128, + 128 + ], + [] + ], + "count": 192, + "cpu_time_us": 3839.257999999594, + "self_cpu_time_us": 787.4050000022835, + "cuda_time_us": 359.8060000004334, + "self_cuda_time_us": 359.8060000004334 + }, + { + "op": "aten::triu", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 64, + 64 + ], + [] + ], + "count": 192, + "cpu_time_us": 3130.7150000002293, + "self_cpu_time_us": 2144.175999999017, + "cuda_time_us": 347.03399999966496, + "self_cuda_time_us": 347.03399999966496 + }, + { + "op": "void at::native::triu_tril_kernel(at::cuda::detail::TensorInfo, at::cuda::detail::TensorInfo, long, long, int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 347.03399999966496, + "self_cuda_time_us": 347.03399999966496 + }, + { + "op": "aten::softplus", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 2790.562999997346, + "self_cpu_time_us": 1822.2729999962758, + "cuda_time_us": 346.0800000009476, + "self_cuda_time_us": 346.0800000009476 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::softplus_kernel(at::TensorIteratorBase&, c10::Scalar const&, c10::Scalar const&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::(anonymous namespace)::softplus_kernel(at::TensorIteratorBase&, c10::Scalar const&, c10::Scalar const&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 346.0800000009476, + "self_cuda_time_us": 346.0800000009476 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 64 + ], + [ + 1, + 1, + 456, + 64 + ] + ], + "count": 128, + "cpu_time_us": 1836.6109999996115, + "self_cpu_time_us": 1225.931999999113, + "cuda_time_us": 345.0890000007639, + "self_cuda_time_us": 345.0890000007639 + }, + { + "op": "void cudnn::engines_precompiled::nchwToNhwcKernel<__nv_bfloat16, __nv_bfloat16, float, false, true, (cudnnKernelDataType_t)0>(cudnn::engines_precompiled::nchw2nhwc_params_t, __nv_bfloat16 const*, __nv_bfloat16*)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 338.2939999999071, + "self_cuda_time_us": 338.2939999999071 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [ + 256 + ] + ], + "count": 64, + "cpu_time_us": 729.0480000001553, + "self_cpu_time_us": 453.2049999992596, + "cuda_time_us": 337.7180000010121, + "self_cuda_time_us": 337.7180000010121 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [ + 1, + 456, + 16, + 1 + ] + ], + "count": 64, + "cpu_time_us": 765.5140000000974, + "self_cpu_time_us": 494.8829999996815, + "cuda_time_us": 335.83400000030815, + "self_cuda_time_us": 335.83400000030815 + }, + { + "op": "aten::pow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 64, + "cpu_time_us": 1043.2379999995755, + "self_cpu_time_us": 718.1150000002235, + "cuda_time_us": 325.688000000373, + "self_cuda_time_us": 325.688000000373 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [] + ], + "count": 384, + "cpu_time_us": 2732.1900000006717, + "self_cpu_time_us": 1237.3940000025177, + "cuda_time_us": 317.3219999996654, + "self_cuda_time_us": 317.3219999996654 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 136, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 303.78000000075554, + "self_cuda_time_us": 303.78000000075554 + }, + { + "op": "aten::exp", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8 + ] + ], + "count": 192, + "cpu_time_us": 2460.0810000002966, + "self_cpu_time_us": 1572.6399999999412, + "cuda_time_us": 289.2509999992908, + "self_cuda_time_us": 289.2509999992908 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::exp_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::exp_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 289.2509999992908, + "self_cuda_time_us": 289.2509999992908 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ], + [ + 32 + ], + [] + ], + "count": 192, + "cpu_time_us": 1959.9519999996264, + "self_cpu_time_us": 1001.0719999997236, + "cuda_time_us": 286.5650000012538, + "self_cuda_time_us": 286.5650000012538 + }, + { + "op": "aten::mean", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [] + ], + "count": 64, + "cpu_time_us": 1026.3910000001488, + "self_cpu_time_us": 733.2420000001148, + "cuda_time_us": 285.8520000000426, + "self_cuda_time_us": 285.8520000000426 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ], + [ + 1, + 456, + 32 + ] + ], + "count": 192, + "cpu_time_us": 2567.842999999426, + "self_cpu_time_us": 1676.053000002008, + "cuda_time_us": 270.0819999999512, + "self_cuda_time_us": 270.0819999999512 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 1 + ], + [ + 1, + 32, + 8, + 64 + ], + [] + ], + "count": 192, + "cpu_time_us": 2686.39400000147, + "self_cpu_time_us": 1787.999000001335, + "cuda_time_us": 266.7920000006998, + "self_cuda_time_us": 266.7920000006998 + }, + { + "op": "aten::sigmoid", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ] + ], + "count": 192, + "cpu_time_us": 3078.2749999991793, + "self_cpu_time_us": 2034.8649999994377, + "cuda_time_us": 263.0699999981589, + "self_cuda_time_us": 263.0699999981589 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [ + 1, + 456, + 4, + 256 + ], + [] + ], + "count": 128, + "cpu_time_us": 1094.0100000000675, + "self_cpu_time_us": 536.0489999992424, + "cuda_time_us": 250.62700000031327, + "self_cuda_time_us": 250.62700000031327 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#9}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#9}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 128, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 234.50400000005902, + "self_cuda_time_us": 234.50400000005902 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 256 + ], + [ + 256 + ], + [] + ], + "count": 128, + "cpu_time_us": 1117.4609999995737, + "self_cpu_time_us": 549.1079999988287, + "cuda_time_us": 232.89900000031048, + "self_cuda_time_us": 232.89900000031048 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 64 + ], + [ + 1, + 1, + 456, + 64 + ] + ], + "count": 128, + "cpu_time_us": 1467.2159999991563, + "self_cpu_time_us": 941.2939999993832, + "cuda_time_us": 231.32900000043446, + "self_cuda_time_us": 231.32900000043446 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 1, + 456, + 4096 + ] + ], + "count": 64, + "cpu_time_us": 795.9840000004624, + "self_cpu_time_us": 496.78600000051665, + "cuda_time_us": 227.9459999993269, + "self_cuda_time_us": 227.9459999993269 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [] + ], + "count": 128, + "cpu_time_us": 1620.8299999991723, + "self_cpu_time_us": 1052.6999999975233, + "cuda_time_us": 223.497999999905, + "self_cuda_time_us": 223.497999999905 + }, + { + "op": "aten::exp", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ] + ], + "count": 192, + "cpu_time_us": 2743.652000000191, + "self_cpu_time_us": 1814.6180000006862, + "cuda_time_us": 220.7040000003617, + "self_cuda_time_us": 220.7040000003617 + }, + { + "op": "aten::sigmoid", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ] + ], + "count": 64, + "cpu_time_us": 908.0559999997204, + "self_cpu_time_us": 587.9630000010948, + "cuda_time_us": 215.79099999985192, + "self_cuda_time_us": 215.79099999985192 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [ + 1 + ], + [] + ], + "count": 192, + "cpu_time_us": 2819.796000000133, + "self_cpu_time_us": 1840.7009999987058, + "cuda_time_us": 203.84300000121584, + "self_cuda_time_us": 203.84300000121584 + }, + { + "op": "void at::native::unrolled_elementwise_kernel, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast>(int, at::native::CUDAFunctor_add, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 203.84300000121584, + "self_cuda_time_us": 203.84300000121584 + }, + { + "op": "aten::rsqrt", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 1 + ] + ], + "count": 192, + "cpu_time_us": 2542.382999999798, + "self_cpu_time_us": 1640.4690000002156, + "cuda_time_us": 203.35600000136765, + "self_cuda_time_us": 203.35600000136765 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 1 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 2829.826000000103, + "self_cpu_time_us": 1963.4360000004672, + "cuda_time_us": 198.6999999996915, + "self_cuda_time_us": 198.6999999996915 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [ + 1, + 456, + 1024 + ], + [] + ], + "count": 128, + "cpu_time_us": 1092.2839999990683, + "self_cpu_time_us": 565.5929999986547, + "cuda_time_us": 196.38300000001618, + "self_cuda_time_us": 196.38300000001618 + }, + { + "op": "aten::neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ] + ], + "count": 192, + "cpu_time_us": 2565.949999998993, + "self_cpu_time_us": 1645.4160000008706, + "cuda_time_us": 190.24900000060734, + "self_cuda_time_us": 190.24900000060734 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 190.24900000060734, + "self_cuda_time_us": 190.24900000060734 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 64, + 64 + ], + [] + ], + "count": 192, + "cpu_time_us": 1821.4140000004409, + "self_cpu_time_us": 937.5310000012687, + "cuda_time_us": 169.52099999965867, + "self_cuda_time_us": 169.52099999965867 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::FillFunctor, std::array, false>(int, at::native::FillFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 169.52099999965867, + "self_cuda_time_us": 169.52099999965867 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 4 + ], + [] + ], + "count": 192, + "cpu_time_us": 2225.912000000768, + "self_cpu_time_us": 1195.7690000018047, + "cuda_time_us": 164.52700000061304, + "self_cuda_time_us": 164.52700000061304 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::FillFunctor, std::array, false>(int, at::native::FillFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 192, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 164.52700000061304, + "self_cuda_time_us": 164.52700000061304 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [ + 256 + ] + ], + "count": 64, + "cpu_time_us": 693.4099999994505, + "self_cpu_time_us": 436.1439999987924, + "cuda_time_us": 161.39400000037858, + "self_cuda_time_us": 161.39400000037858 + }, + { + "op": "aten::mean", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [] + ], + "count": 64, + "cpu_time_us": 959.7449999998935, + "self_cpu_time_us": 682.2539999995788, + "cuda_time_us": 161.3939999993745, + "self_cuda_time_us": 161.3939999993745 + }, + { + "op": "Memcpy DtoH (Device -> Pinned)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 168, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 160.7450000014942, + "self_cuda_time_us": 160.7450000014942 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [ + 1, + 456, + 4, + 1 + ] + ], + "count": 64, + "cpu_time_us": 729.7240000001038, + "self_cpu_time_us": 462.9080000002141, + "cuda_time_us": 159.55499999992026, + "self_cuda_time_us": 159.55499999992026 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 64 + ], + [ + 1, + 16, + 456, + 64 + ], + [] + ], + "count": 64, + "cpu_time_us": 863.6160000004165, + "self_cpu_time_us": 577.6630000016157, + "cuda_time_us": 151.5380000002042, + "self_cuda_time_us": 151.5380000002042 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 4096, + 16 + ] + ], + "count": 16, + "cpu_time_us": 354.9319999999716, + "self_cpu_time_us": 218.83900000054564, + "cuda_time_us": 138.06499999990046, + "self_cuda_time_us": 138.06499999990046 + }, + { + "op": "aten::_local_scalar_dense", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [] + ], + "count": 152, + "cpu_time_us": 1898.4160000011289, + "self_cpu_time_us": 705.9110000033215, + "cuda_time_us": 137.8670000009879, + "self_cuda_time_us": 137.8670000009879 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4, + 1024 + ], + [ + 1200, + 4, + 1 + ] + ], + "count": 8, + "cpu_time_us": 138.32200000020384, + "self_cpu_time_us": 92.13599999995495, + "cuda_time_us": 126.73600000035367, + "self_cuda_time_us": 126.73600000035367 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 126.73600000035367, + "self_cuda_time_us": 126.73600000035367 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 256 + ], + [], + [] + ], + "count": 128, + "cpu_time_us": 1396.377000000648, + "self_cpu_time_us": 895.7290000022331, + "cuda_time_us": 126.00099999873783, + "self_cuda_time_us": 126.00099999873783 + }, + { + "op": "aten::neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 32 + ] + ], + "count": 64, + "cpu_time_us": 1047.4850000007282, + "self_cpu_time_us": 719.543000000951, + "cuda_time_us": 125.61999999986438, + "self_cuda_time_us": 125.61999999986438 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 64 + ], + [ + 1, + 4, + 456, + 64 + ], + [] + ], + "count": 64, + "cpu_time_us": 701.3890000003157, + "self_cpu_time_us": 447.36600000126055, + "cuda_time_us": 117.62100000036298, + "self_cuda_time_us": 117.62100000036298 + }, + { + "op": "aten::pow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [] + ], + "count": 64, + "cpu_time_us": 960.1080000013608, + "self_cpu_time_us": 648.0890000028303, + "cuda_time_us": 111.15499999964959, + "self_cuda_time_us": 111.15499999964959 + }, + { + "op": "aten::masked_scatter_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 2560 + ], + [ + 300, + 2560 + ] + ], + "count": 8, + "cpu_time_us": 712.616000000111, + "self_cpu_time_us": 302.8089999988297, + "cuda_time_us": 132.0120000005263, + "self_cuda_time_us": 109.74500000011176 + }, + { + "op": "aten::nonzero", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ] + ], + "count": 24, + "cpu_time_us": 1699.879999999379, + "self_cpu_time_us": 833.3689999999915, + "cuda_time_us": 109.14000000077067, + "self_cuda_time_us": 109.14000000077067 + }, + { + "op": "aten::neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 32 + ] + ], + "count": 64, + "cpu_time_us": 778.6999999999825, + "self_cpu_time_us": 497.29900000049383, + "cuda_time_us": 108.88400000019465, + "self_cuda_time_us": 108.88400000019465 + }, + { + "op": "aten::cumsum", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 1859.6399999996793, + "self_cpu_time_us": 1108.424000001396, + "cuda_time_us": 114.86200000031386, + "self_cuda_time_us": 104.91099999999278 + }, + { + "op": "aten::sum", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4, + 1024 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 184.53099999974074, + "self_cpu_time_us": 135.96000000007916, + "cuda_time_us": 90.38999999960652, + "self_cuda_time_us": 90.38999999960652 + }, + { + "op": "void at::native::reduce_kernel<128, 4, at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(float, float)#1}>, unsigned int, float, 4, 4> >(at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(float, float)#1}>, unsigned int, float, 4, 4>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 90.38999999960652, + "self_cuda_time_us": 90.38999999960652 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 300, + 4096 + ], + [] + ], + "count": 24, + "cpu_time_us": 220.42700000050536, + "self_cpu_time_us": 111.28900000057183, + "cuda_time_us": 86.64499999961117, + "self_cuda_time_us": 86.64499999961117 + }, + { + "op": "void at::native::vectorized_gather_kernel<16, long>(char*, char*, long*, int, long, long, long, long, bool)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 81.94199999968987, + "self_cuda_time_us": 81.94199999968987 + }, + { + "op": "void at::native::unrolled_elementwise_kernel, 4, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1> >(int, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}, std::array, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 40, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 78.81500000020606, + "self_cuda_time_us": 78.81500000020606 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::CUDAFunctorOnSelf_add, std::array, false>(int, at::native::CUDAFunctorOnSelf_add, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 72, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 75.37699999992037, + "self_cuda_time_us": 75.37699999992037 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [ + 1, + 456 + ], + [] + ], + "count": 56, + "cpu_time_us": 2913.654999999533, + "self_cpu_time_us": 334.4690000004048, + "cuda_time_us": 73.88199999985227, + "self_cuda_time_us": 73.88199999985227 + }, + { + "op": "aten::rsqrt", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 1 + ] + ], + "count": 64, + "cpu_time_us": 680.7500000001746, + "self_cpu_time_us": 418.2770000000455, + "cuda_time_us": 72.28299999989395, + "self_cuda_time_us": 72.28299999989395 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 1 + ], + [], + [] + ], + "count": 64, + "cpu_time_us": 748.9510000001756, + "self_cpu_time_us": 488.70800000026065, + "cuda_time_us": 68.73400000068068, + "self_cuda_time_us": 68.73400000068068 + }, + { + "op": "aten::rsqrt", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 1 + ] + ], + "count": 64, + "cpu_time_us": 723.105000000156, + "self_cpu_time_us": 454.5200000000914, + "cuda_time_us": 68.15300000157731, + "self_cuda_time_us": 68.15300000157731 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 1 + ], + [], + [] + ], + "count": 64, + "cpu_time_us": 800.7249999996566, + "self_cpu_time_us": 537.7700000005716, + "cuda_time_us": 66.52900000031514, + "self_cuda_time_us": 66.52900000031514 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::BUnaryFunctor, std::array, false>(int, at::native::BUnaryFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 40, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 65.97099999987404, + "self_cuda_time_us": 65.97099999987404 + }, + { + "op": "aten::gather", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [ + 1200 + ], + [], + [ + 1200 + ] + ], + "count": 24, + "cpu_time_us": 339.93400000011025, + "self_cpu_time_us": 198.18900000040594, + "cuda_time_us": 65.81599999958416, + "self_cuda_time_us": 65.81599999958416 + }, + { + "op": "void at::native::_scatter_gather_elementwise_kernel<128, 8, at::native::_cuda_scatter_gather_internal_kernel, long>::operator()(at::TensorIterator&, long, long, long, at::native::TensorAssign const&)::{lambda(int)#1}>(int, at::native::_cuda_scatter_gather_internal_kernel, long>::operator()(at::TensorIterator&, long, long, long, at::native::TensorAssign const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 65.81599999958416, + "self_cuda_time_us": 65.81599999958416 + }, + { + "op": "void at::native::unrolled_elementwise_kernel, 4, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1> >(int, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#11}::operator()() const::{lambda(bool)#1}, std::array, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 32, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 64.9199999991688, + "self_cuda_time_us": 64.9199999991688 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ], + [] + ], + "count": 32, + "cpu_time_us": 314.8789999995497, + "self_cpu_time_us": 162.21099999902071, + "cuda_time_us": 63.00299999945855, + "self_cuda_time_us": 63.00299999945855 + }, + { + "op": "void at::native::reduce_kernel<512, 1, at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(long, long)#1}>, unsigned int, long, 4, 4> >(at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(long, long)#1}>, unsigned int, long, 4, 4>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 32, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 62.58499999938067, + "self_cuda_time_us": 62.58499999938067 + }, + { + "op": "aten::gather", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2304, + 1024 + ], + [], + [ + 4800, + 1024 + ], + [], + [ + 4800, + 1024 + ] + ], + "count": 8, + "cpu_time_us": 157.2249999998603, + "self_cpu_time_us": 101.37200000032317, + "cuda_time_us": 61.39999999979045, + "self_cuda_time_us": 61.39999999979045 + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceScanKernel >::Policy1000, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, long*, at_cuda_detail::cub::ScanTileState, at::cuda::cub::(anonymous namespace)::SumOp, at_cuda_detail::cub::detail::InputValue, unsigned int, long, false, long>(thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, long*, at_cuda_detail::cub::ScanTileState, int, at::cuda::cub::(anonymous namespace)::SumOp, at_cuda_detail::cub::detail::InputValue, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 61.27300000017567, + "self_cuda_time_us": 61.27300000017567 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [ + 456 + ], + [] + ], + "count": 32, + "cpu_time_us": 393.3200000001234, + "self_cpu_time_us": 162.93300000012096, + "cuda_time_us": 59.831999999601976, + "self_cuda_time_us": 59.831999999601976 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 300, + 4096 + ], + [] + ], + "count": 8, + "cpu_time_us": 87.99800000019604, + "self_cpu_time_us": 53.5300000004645, + "cuda_time_us": 57.20999999981723, + "self_cuda_time_us": 57.20999999981723 + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceScanKernel >::Policy1000, long const*, long*, at_cuda_detail::cub::ScanTileState, std::plus, at_cuda_detail::cub::NullType, unsigned int, long, false, at_cuda_detail::cub::NullType>(long const*, long*, at_cuda_detail::cub::ScanTileState, int, std::plus, at_cuda_detail::cub::NullType, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 40, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 53.2419999998674, + "self_cuda_time_us": 53.2419999998674 + }, + { + "op": "aten::index", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [] + ], + "count": 16, + "cpu_time_us": 1635.6539999995584, + "self_cpu_time_us": 307.3859999994165, + "cuda_time_us": 126.32100000091305, + "self_cuda_time_us": 53.23900000065623 + }, + { + "op": "void at::native::index_elementwise_kernel<128, 4, at::native::gpu_index_kernel >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_kernel_impl >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1}>(long, at::native::gpu_index_kernel >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_kernel_impl >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 53.23900000065623, + "self_cuda_time_us": 53.23900000065623 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::AUnaryFunctor >, std::array, false>(int, at::native::AUnaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 48, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 52.95299999983399, + "self_cuda_time_us": 52.95299999983399 + }, + { + "op": "aten::sum", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "count": 24, + "cpu_time_us": 1078.7759999994742, + "self_cpu_time_us": 451.1899999998277, + "cuda_time_us": 95.09600000029604, + "self_cuda_time_us": 47.385999999562046 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::AUnaryFunctor >, std::array, false>(int, at::native::AUnaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 40, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 45.913000000917236, + "self_cuda_time_us": 45.913000000917236 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 32, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 45.112999999910244, + "self_cuda_time_us": 45.112999999910244 + }, + { + "op": "aten::floor_divide", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [] + ], + "count": 24, + "cpu_time_us": 384.8430000000226, + "self_cpu_time_us": 180.72700000020268, + "cuda_time_us": 43.92800000010175, + "self_cuda_time_us": 43.92800000010175 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [] + ], + "count": 40, + "cpu_time_us": 471.46999999901163, + "self_cpu_time_us": 305.75699999855715, + "cuda_time_us": 43.456000000296626, + "self_cuda_time_us": 43.456000000296626 + }, + { + "op": "aten::repeat_interleave", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 32, + "cpu_time_us": 4267.656000000206, + "self_cpu_time_us": 599.3630000000994, + "cuda_time_us": 239.13099999974656, + "self_cuda_time_us": 43.1309999996156 + }, + { + "op": "void compute_cuda_kernel(long const*, long const*, long*, long, long)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 32, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 43.1309999996156, + "self_cuda_time_us": 43.1309999996156 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1 + ], + [ + 2 + ], + [] + ], + "count": 16, + "cpu_time_us": 195.9320000000298, + "self_cpu_time_us": 127.27499999960128, + "cuda_time_us": 42.68400000000838, + "self_cuda_time_us": 42.68400000000838 + }, + { + "op": "aten::div", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ] + ], + "count": 16, + "cpu_time_us": 241.50399999995716, + "self_cpu_time_us": 155.69299999983923, + "cuda_time_us": 42.20299999987765, + "self_cuda_time_us": 42.20299999987765 + }, + { + "op": "void at::native::unrolled_elementwise_kernel >, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1> >(int, at::native::BinaryFunctor >, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 42.20299999987765, + "self_cuda_time_us": 42.20299999987765 + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceScanInitKernel >(at_cuda_detail::cub::ScanTileState, int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 48, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 39.7680000004475, + "self_cuda_time_us": 39.7680000004475 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [] + ], + "count": 40, + "cpu_time_us": 450.2679999994143, + "self_cpu_time_us": 139.41099999986182, + "cuda_time_us": 38.842000000193366, + "self_cuda_time_us": 38.842000000193366 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::(anonymous namespace)::launch_clamp_scalar(at::TensorIteratorBase&, c10::Scalar, c10::Scalar, at::native::detail::ClampLimits)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}, std::array, false>(int, at::native::(anonymous namespace)::launch_clamp_scalar(at::TensorIteratorBase&, c10::Scalar, c10::Scalar, at::native::detail::ClampLimits)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 32, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 37.37200000000303, + "self_cuda_time_us": 37.37200000000303 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 16, + 4096 + ] + ], + "count": 8, + "cpu_time_us": 120.09399999992456, + "self_cpu_time_us": 87.82600000003004, + "cuda_time_us": 36.79499999980908, + "self_cuda_time_us": 36.79499999980908 + }, + { + "op": "aten::clamp", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [] + ], + "count": 32, + "cpu_time_us": 458.191999999719, + "self_cpu_time_us": 298.06900000084715, + "cuda_time_us": 35.93200000008801, + "self_cuda_time_us": 35.93200000008801 + }, + { + "op": "void at_cuda_detail::cub::detail::select::DeviceSelectSweepKernel::Policy1000, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::counting_iterator, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, long*, int*, at_cuda_detail::cub::ScanTileState, at_cuda_detail::cub::NullType, at_cuda_detail::cub::NullType, int, at_cuda_detail::cub::detail::select::streaming_context_t, (at_cuda_detail::cub::SelectImpl)0>(thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::counting_iterator, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, long*, int*, at_cuda_detail::cub::ScanTileState, at_cuda_detail::cub::NullType, at_cuda_detail::cub::NullType, int, int, at_cuda_detail::cub::detail::select::streaming_context_t, at_cuda_detail::cub::detail::vsmem_t)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 35.578999999692314, + "self_cuda_time_us": 35.578999999692314 + }, + { + "op": "aten::add_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024, + 1, + 1, + 1 + ], + [ + 1, + 1024, + 1, + 1, + 1 + ], + [] + ], + "count": 8, + "cpu_time_us": 122.34099999979662, + "self_cpu_time_us": 79.51899999982561, + "cuda_time_us": 34.62100000018836, + "self_cuda_time_us": 34.62100000018836 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::launch_masked_scatter_kernel(at::TensorBase const&, at::TensorBase const&, at::TensorBase const&, at::TensorBase const&)::{lambda()#1}::operator()() const::{lambda()#11}::operator()() const::{lambda(c10::BFloat16, bool, long)#1}, std::array, false>(int, at::native::launch_masked_scatter_kernel(at::TensorBase const&, at::TensorBase const&, at::TensorBase const&, at::TensorBase const&)::{lambda()#1}::operator()() const::{lambda()#11}::operator()() const::{lambda(c10::BFloat16, bool, long)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 34.138999999908265, + "self_cuda_time_us": 34.138999999908265 + }, + { + "op": "aten::ge", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 32, + "cpu_time_us": 518.1249999996071, + "self_cpu_time_us": 355.2139999991341, + "cuda_time_us": 33.14499999961117, + "self_cuda_time_us": 33.14499999961117 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::compare_scalar_kernel(at::TensorIteratorBase&, at::native::(anonymous namespace)::OpType, long)::{lambda(long)#1}, std::array, false>(int, at::native::compare_scalar_kernel(at::TensorIteratorBase&, at::native::(anonymous namespace)::OpType, long)::{lambda(long)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 32, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 33.14499999961117, + "self_cuda_time_us": 33.14499999961117 + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy, unsigned int, 2, 64, 64>(at::native::(anonymous namespace)::OpaqueType<4u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 64, 64>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 31.198000000222237, + "self_cuda_time_us": 31.198000000222237 + }, + { + "op": "void at_cuda_detail::cub::detail::reduce::DeviceReduceSingleTileKernel >::Policy1000, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, int*, unsigned long long, cuda::std::__4::plus, int, int, cuda::std::__4::__identity>(thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, int*, unsigned long long, cuda::std::__4::plus, int, cuda::std::__4::__identity)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 30.9730000004638, + "self_cuda_time_us": 30.9730000004638 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::CUDAFunctor_add, std::array, false>(int, at::native::CUDAFunctor_add, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 29.37299999986135, + "self_cuda_time_us": 29.37299999986135 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [] + ], + "count": 8, + "cpu_time_us": 103.89299999989453, + "self_cpu_time_us": 62.91600000023027, + "cuda_time_us": 29.34000000008382, + "self_cuda_time_us": 29.34000000008382 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [ + 300, + 2560 + ], + [] + ], + "count": 8, + "cpu_time_us": 87.79799999967508, + "self_cpu_time_us": 52.99599999948987, + "cuda_time_us": 29.244000000006054, + "self_cuda_time_us": 29.244000000006054 + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 16, + 2560 + ] + ], + "count": 8, + "cpu_time_us": 117.06500000001688, + "self_cpu_time_us": 85.11999999996624, + "cuda_time_us": 28.702000000077533, + "self_cuda_time_us": 28.702000000077533 + }, + { + "op": "aten::eq", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "count": 24, + "cpu_time_us": 360.0109999995475, + "self_cpu_time_us": 239.81399999956193, + "cuda_time_us": 28.44500000019616, + "self_cuda_time_us": 28.44500000019616 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::cos_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::cos_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 28.350999999631313, + "self_cuda_time_us": 28.350999999631313 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::sin_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::sin_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 27.421000000307686, + "self_cuda_time_us": 27.421000000307686 + }, + { + "op": "aten::_index_put_impl_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 456 + ], + [], + [ + 3, + 456 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 772.2940000001108, + "self_cpu_time_us": 139.99600000027567, + "cuda_time_us": 63.096000000296044, + "self_cuda_time_us": 27.037999999782187 + }, + { + "op": "void at::native::index_elementwise_kernel<128, 4, at::native::gpu_index_kernel >(at::TensorIterator&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_put_kernel_impl >(at::TensorIterator&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1}>(long, at::native::gpu_index_kernel >(at::TensorIterator&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_put_kernel_impl >(at::TensorIterator&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 27.037999999782187, + "self_cuda_time_us": 27.037999999782187 + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy_alignedK_contig, unsigned int, 2, 128, 1, 16>(at::native::(anonymous namespace)::OpaqueType<8u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 128, 1>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 26.78199999962817, + "self_cuda_time_us": 26.78199999962817 + }, + { + "op": "aten::remainder", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ] + ], + "count": 16, + "cpu_time_us": 242.12199999968288, + "self_cpu_time_us": 152.99399999939487, + "cuda_time_us": 26.302000000418047, + "self_cuda_time_us": 26.302000000418047 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::BinaryFunctor, std::array, false>(int, at::native::BinaryFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 26.302000000418047, + "self_cuda_time_us": 26.302000000418047 + }, + { + "op": "aten::remainder", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [] + ], + "count": 16, + "cpu_time_us": 256.53300000025774, + "self_cpu_time_us": 180.29500000020198, + "cuda_time_us": 25.915000000226428, + "self_cuda_time_us": 25.915000000226428 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::BUnaryFunctor, std::array, false>(int, at::native::BUnaryFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 25.915000000226428, + "self_cuda_time_us": 25.915000000226428 + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy_vectorized, unsigned int, 2, 128, 1, 16, 4>(char*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 128, 1>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 25.27700000035111, + "self_cuda_time_us": 25.27700000035111 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [ + 1 + ] + ], + "count": 24, + "cpu_time_us": 410.85199999985343, + "self_cpu_time_us": 261.5339999995922, + "cuda_time_us": 24.19099999978789, + "self_cuda_time_us": 24.19099999978789 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1 + ], + [ + 2 + ], + [] + ], + "count": 16, + "cpu_time_us": 223.5150000006106, + "self_cpu_time_us": 149.32800000092539, + "cuda_time_us": 22.937999999834574, + "self_cuda_time_us": 22.937999999834574 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [ + 3 + ], + [] + ], + "count": 24, + "cpu_time_us": 34823.82699999941, + "self_cpu_time_us": 163.16299999895273, + "cuda_time_us": 22.748999999661464, + "self_cuda_time_us": 22.748999999661464 + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#11}::operator()() const::{lambda(bool)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#11}::operator()() const::{lambda(bool)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 22.267000000414555, + "self_cuda_time_us": 22.267000000414555 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15, + 20, + 2, + 2 + ], + [ + 15, + 20, + 2, + 2 + ], + [] + ], + "count": 16, + "cpu_time_us": 193.23800000047777, + "self_cpu_time_us": 94.96900000041933, + "cuda_time_us": 22.076999999946565, + "self_cuda_time_us": 22.076999999946565 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 22.076999999946565, + "self_cuda_time_us": 22.076999999946565 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 11 + ], + [ + 1, + 456, + 11 + ], + [] + ], + "count": 16, + "cpu_time_us": 184.6420000000362, + "self_cpu_time_us": 108.82000000006519, + "cuda_time_us": 21.756999999604886, + "self_cuda_time_us": 21.756999999604886 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 10 + ], + [ + 1, + 456, + 10 + ], + [] + ], + "count": 16, + "cpu_time_us": 146.39100000048347, + "self_cpu_time_us": 77.22300000042014, + "cuda_time_us": 21.019000000480446, + "self_cuda_time_us": 21.019000000480446 + }, + { + "op": "aten::gather", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320, + 2560 + ], + [], + [ + 456, + 2560 + ], + [], + [ + 456, + 2560 + ] + ], + "count": 8, + "cpu_time_us": 328.8240000002552, + "self_cpu_time_us": 166.46000000047206, + "cuda_time_us": 20.541999999899417, + "self_cuda_time_us": 20.541999999899417 + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceCompactInitKernel, int*>(at_cuda_detail::cub::ScanTileState, int, int*)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 24, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 19.710000000108266, + "self_cuda_time_us": 19.710000000108266 + }, + { + "op": "aten::gelu", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [] + ], + "count": 8, + "cpu_time_us": 116.09799999983807, + "self_cpu_time_us": 67.81799999919895, + "cuda_time_us": 19.70899999975518, + "self_cuda_time_us": 19.70899999975518 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::GeluCUDAKernelImpl(at::TensorIteratorBase&, at::native::GeluType)::{lambda()#2}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array, false>(int, at::native::GeluCUDAKernelImpl(at::TensorIteratorBase&, at::native::GeluType)::{lambda()#2}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 19.70899999975518, + "self_cuda_time_us": 19.70899999975518 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ], + [] + ], + "count": 16, + "cpu_time_us": 186.7609999999113, + "self_cpu_time_us": 123.11500000009255, + "cuda_time_us": 19.455999999991036, + "self_cuda_time_us": 19.455999999991036 + }, + { + "op": "aten::index", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320 + ], + [] + ], + "count": 8, + "cpu_time_us": 312.127000000095, + "self_cpu_time_us": 196.24099999992177, + "cuda_time_us": 19.134999999660067, + "self_cuda_time_us": 19.134999999660067 + }, + { + "op": "void at::native::index_elementwise_kernel<128, 4, at::native::gpu_index_kernel >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_kernel_impl >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1}>(long, at::native::gpu_index_kernel >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_kernel_impl >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 19.134999999660067, + "self_cuda_time_us": 19.134999999660067 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [] + ], + "count": 8, + "cpu_time_us": 93.98300000003655, + "self_cpu_time_us": 60.75399999963702, + "cuda_time_us": 19.00699999961944, + "self_cuda_time_us": 19.00699999961944 + }, + { + "op": "aten::clamp", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [], + [] + ], + "count": 16, + "cpu_time_us": 273.5129999998462, + "self_cpu_time_us": 190.9229999998206, + "cuda_time_us": 18.5889999998617, + "self_cuda_time_us": 18.5889999998617 + }, + { + "op": "aten::max", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 456 + ] + ], + "count": 8, + "cpu_time_us": 212.39600000032806, + "self_cpu_time_us": 129.624000000229, + "cuda_time_us": 18.463000000090688, + "self_cuda_time_us": 18.463000000090688 + }, + { + "op": "void at::native::reduce_kernel<512, 1, at::native::ReduceOp >, unsigned int, long, 4, 4> >(at::native::ReduceOp >, unsigned int, long, 4, 4>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 18.463000000090688, + "self_cuda_time_us": 18.463000000090688 + }, + { + "op": "aten::floor_divide", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ] + ], + "count": 8, + "cpu_time_us": 137.9319999999716, + "self_cpu_time_us": 62.790999999822816, + "cuda_time_us": 18.301000000268687, + "self_cuda_time_us": 18.301000000268687 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::BinaryFunctor, std::array, false>(int, at::native::BinaryFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 18.301000000268687, + "self_cuda_time_us": 18.301000000268687 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::BinaryFunctor >, std::array, false>(int, at::native::BinaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 18.208999999667867, + "self_cuda_time_us": 18.208999999667867 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [], + [] + ], + "count": 16, + "cpu_time_us": 199.42799999960698, + "self_cpu_time_us": 131.36099999964063, + "cuda_time_us": 18.142999999938183, + "self_cuda_time_us": 18.142999999938183 + }, + { + "op": "aten::prod", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 216.26400000006834, + "self_cpu_time_us": 164.36000000037893, + "cuda_time_us": 17.98100000015984, + "self_cuda_time_us": 17.98100000015984 + }, + { + "op": "reduction_prod_kernel", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 17.98100000015984, + "self_cuda_time_us": 17.98100000015984 + }, + { + "op": "aten::eq", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 16, + "cpu_time_us": 237.30899999990652, + "self_cpu_time_us": 161.93400000028487, + "cuda_time_us": 17.468000000721077, + "self_cuda_time_us": 17.468000000721077 + }, + { + "op": "aten::all", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "count": 8, + "cpu_time_us": 173.73399999989488, + "self_cpu_time_us": 121.58799999995972, + "cuda_time_us": 17.215000000054715, + "self_cuda_time_us": 17.215000000054715 + }, + { + "op": "void at::native::reduce_kernel<512, 1, at::native::ReduceOp, unsigned int, bool, 4, 4> >(at::native::ReduceOp, unsigned int, bool, 4, 4>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 17.215000000054715, + "self_cuda_time_us": 17.215000000054715 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::launch_clamp_scalar(at::TensorIteratorBase&, c10::Scalar, c10::Scalar, at::native::detail::ClampLimits)::{lambda()#1}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::(anonymous namespace)::launch_clamp_scalar(at::TensorIteratorBase&, c10::Scalar, c10::Scalar, at::native::detail::ClampLimits)::{lambda()#1}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 17.148999999946682, + "self_cuda_time_us": 17.148999999946682 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1 + ], + [ + 1200, + 1 + ], + [] + ], + "count": 16, + "cpu_time_us": 195.40499999978056, + "self_cpu_time_us": 125.416999999361, + "cuda_time_us": 17.147000000128173, + "self_cuda_time_us": 17.147000000128173 + }, + { + "op": "aten::floor", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ] + ], + "count": 16, + "cpu_time_us": 221.35100000025705, + "self_cpu_time_us": 141.36199999983364, + "cuda_time_us": 16.83200000002398, + "self_cuda_time_us": 16.83200000002398 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::floor_kernel_cuda(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::floor_kernel_cuda(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 16.83200000002398, + "self_cuda_time_us": 16.83200000002398 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [ + 1200, + 2 + ], + [] + ], + "count": 16, + "cpu_time_us": 214.40499999999884, + "self_cpu_time_us": 132.84899999956542, + "cuda_time_us": 16.441999999951804, + "self_cuda_time_us": 16.441999999951804 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::CUDAFunctorOnOther_add, std::array, false>(int, at::native::CUDAFunctorOnOther_add, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 16.441999999951804, + "self_cuda_time_us": 16.441999999951804 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 16 + ], + [] + ], + "count": 16, + "cpu_time_us": 215.64299999957439, + "self_cpu_time_us": 145.95699999999488, + "cuda_time_us": 16.413999999742373, + "self_cuda_time_us": 16.413999999742373 + }, + { + "op": "aten::abs", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [ + 0 + ] + ], + "count": 16, + "cpu_time_us": 249.6050000001269, + "self_cpu_time_us": 126.24900000054913, + "cuda_time_us": 16.413000000218744, + "self_cuda_time_us": 16.413000000218744 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::AbsFunctor, std::array, false>(int, at::native::AbsFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 16.413000000218744, + "self_cuda_time_us": 16.413000000218744 + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy, unsigned int, 3, 64, 64>(at::native::(anonymous namespace)::OpaqueType<8u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 64, 64>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 16.380999999979394, + "self_cuda_time_us": 16.380999999979394 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 64 + ], + [ + 1, + 456, + 64 + ], + [] + ], + "count": 16, + "cpu_time_us": 143.59699999949953, + "self_cpu_time_us": 75.27799999920535, + "cuda_time_us": 16.255999999310006, + "self_cuda_time_us": 16.255999999310006 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [ + 1200, + 2, + 1 + ], + [] + ], + "count": 8, + "cpu_time_us": 82.46999999988475, + "self_cpu_time_us": 41.24699999993027, + "cuda_time_us": 16.157999999821186, + "self_cuda_time_us": 16.157999999821186 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456, + 32 + ], + [] + ], + "count": 16, + "cpu_time_us": 265.81599999991886, + "self_cpu_time_us": 179.43400000029942, + "cuda_time_us": 16.126999999862164, + "self_cuda_time_us": 16.126999999862164 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 528.5809999998019, + "self_cpu_time_us": 122.9579999998241, + "cuda_time_us": 16.090999999956694, + "self_cuda_time_us": 16.090999999956694 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [ + 3, + 1, + 1, + 456 + ], + [] + ], + "count": 8, + "cpu_time_us": 92.70700000022771, + "self_cpu_time_us": 46.09200000032433, + "cuda_time_us": 15.869000000238884, + "self_cuda_time_us": 15.869000000238884 + }, + { + "op": "void at::native::unrolled_elementwise_kernel >, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast>(int, at::native::BinaryFunctor >, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 15.55100000006496, + "self_cuda_time_us": 15.55100000006496 + }, + { + "op": "aten::sum", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 8, + "cpu_time_us": 190.10199999986799, + "self_cpu_time_us": 144.1619999998802, + "cuda_time_us": 15.198999999818625, + "self_cuda_time_us": 15.198999999818625 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [ + 300, + 2560 + ], + [] + ], + "count": 8, + "cpu_time_us": 68.8469999996887, + "self_cpu_time_us": 35.55799999984447, + "cuda_time_us": 14.430999999676715, + "self_cuda_time_us": 14.430999999676715 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::FillFunctor, std::array, false>(int, at::native::FillFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 16, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 14.424999999784632, + "self_cuda_time_us": 14.424999999784632 + }, + { + "op": "aten::cos", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456, + 32 + ] + ], + "count": 8, + "cpu_time_us": 149.31499999992957, + "self_cpu_time_us": 99.28500000001804, + "cuda_time_us": 14.303999999756343, + "self_cuda_time_us": 14.303999999756343 + }, + { + "op": "aten::cos", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 16 + ] + ], + "count": 8, + "cpu_time_us": 122.48299999978917, + "self_cpu_time_us": 78.7309999998397, + "cuda_time_us": 14.04699999987497, + "self_cuda_time_us": 14.04699999987497 + }, + { + "op": "aten::sin", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456, + 32 + ] + ], + "count": 8, + "cpu_time_us": 111.23399999951653, + "self_cpu_time_us": 72.62599999914528, + "cuda_time_us": 13.823000000265893, + "self_cuda_time_us": 13.823000000265893 + }, + { + "op": "aten::sin", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 16 + ] + ], + "count": 8, + "cpu_time_us": 115.22399999957997, + "self_cpu_time_us": 74.41199999973469, + "cuda_time_us": 13.598000000041793, + "self_cuda_time_us": 13.598000000041793 + }, + { + "op": "aten::index_select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [ + 1 + ] + ], + "count": 8, + "cpu_time_us": 199.87399999967602, + "self_cpu_time_us": 106.56399999943096, + "cuda_time_us": 13.278000000063912, + "self_cuda_time_us": 13.278000000063912 + }, + { + "op": "void at::native::(anonymous namespace)::indexSelectSmallIndex(at::cuda::detail::TensorInfo, at::cuda::detail::TensorInfo, at::cuda::detail::TensorInfo, int, int, unsigned int, long)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 13.278000000063912, + "self_cuda_time_us": 13.278000000063912 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [ + 16 + ] + ], + "count": 8, + "cpu_time_us": 118.70799999998417, + "self_cpu_time_us": 78.8870000000752, + "cuda_time_us": 12.221999999936088, + "self_cuda_time_us": 12.221999999936088 + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceScanKernel >::Policy1000, int const*, int*, at_cuda_detail::cub::ScanTileState, std::plus, at_cuda_detail::cub::NullType, unsigned int, int, false, at_cuda_detail::cub::NullType>(int const*, int*, at_cuda_detail::cub::ScanTileState, int, std::plus, at_cuda_detail::cub::NullType, unsigned int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 11.87099999973725, + "self_cuda_time_us": 11.87099999973725 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [ + 1, + 3 + ], + [] + ], + "count": 16, + "cpu_time_us": 285.5940000001574, + "self_cpu_time_us": 85.42099999998754, + "cuda_time_us": 11.838999999861699, + "self_cuda_time_us": 11.838999999861699 + }, + { + "op": "aten::floor_divide", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 8, + "cpu_time_us": 180.73799999996845, + "self_cpu_time_us": 95.56800000018848, + "cuda_time_us": 11.583999999784282, + "self_cuda_time_us": 11.583999999784282 + }, + { + "op": "_native::bmm_triton_0", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 32, + 1 + ], + [ + 3, + 1, + 456 + ] + ], + "count": 8, + "cpu_time_us": 1474.1430000001128, + "self_cpu_time_us": 1371.3009999999485, + "cuda_time_us": 11.519000000087544, + "self_cuda_time_us": 11.519000000087544 + }, + { + "op": "_bmm_outer_product_kernel", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 11.519000000087544, + "self_cuda_time_us": 11.519000000087544 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 79 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 140.7980000002717, + "self_cpu_time_us": 95.9740000002057, + "cuda_time_us": 11.35799999977462, + "self_cuda_time_us": 11.35799999977462 + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctorOnSelf_add const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctorOnSelf_add const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 11.35799999977462, + "self_cuda_time_us": 11.35799999977462 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [ + 1200, + 1, + 2 + ], + [] + ], + "count": 8, + "cpu_time_us": 97.97600000003877, + "self_cpu_time_us": 65.05900000000838, + "cuda_time_us": 11.294999999881838, + "self_cuda_time_us": 11.294999999881838 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [ + 1200, + 1, + 2 + ] + ], + "count": 8, + "cpu_time_us": 106.57700000003388, + "self_cpu_time_us": 67.22100000019418, + "cuda_time_us": 11.100999999849591, + "self_cuda_time_us": 11.100999999849591 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 77 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 122.88200000021607, + "self_cpu_time_us": 81.81400000002759, + "cuda_time_us": 10.880000000193832, + "self_cuda_time_us": 10.880000000193832 + }, + { + "op": "aten::floor_divide", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 16, + "cpu_time_us": 239.77900000007867, + "self_cpu_time_us": 156.46500000013657, + "cuda_time_us": 10.45899999998801, + "self_cuda_time_us": 10.45899999998801 + }, + { + "op": "void at::native::unrolled_elementwise_kernel, 4, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1> >(int, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#3}::operator()() const::{lambda(int)#1}, std::array, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 9.951000000321073, + "self_cuda_time_us": 9.951000000321073 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ], + [] + ], + "count": 8, + "cpu_time_us": 135.6159999998781, + "self_cpu_time_us": 90.98099999994156, + "cuda_time_us": 9.916999999870313, + "self_cuda_time_us": 9.916999999870313 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ] + ], + "count": 8, + "cpu_time_us": 97.19499999967229, + "self_cpu_time_us": 61.58999999947264, + "cuda_time_us": 9.568999999944936, + "self_cuda_time_us": 9.568999999944936 + }, + { + "op": "aten::gt", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 8, + "cpu_time_us": 141.0780000003433, + "self_cpu_time_us": 96.94200000009732, + "cuda_time_us": 9.375000000116415, + "self_cuda_time_us": 9.375000000116415 + }, + { + "op": "void at::native::unrolled_elementwise_kernel, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast>(int, at::native::(anonymous namespace)::CompareFunctor, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 9.375000000116415, + "self_cuda_time_us": 9.375000000116415 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 8, + "cpu_time_us": 117.97899999980291, + "self_cpu_time_us": 79.17600000005041, + "cuda_time_us": 9.211999999984982, + "self_cuda_time_us": 9.211999999984982 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [] + ], + "count": 8, + "cpu_time_us": 96.33199999968929, + "self_cpu_time_us": 63.26199999934761, + "cuda_time_us": 8.895000000033178, + "self_cuda_time_us": 8.895000000033178 + }, + { + "op": "aten::_softmax", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 162.15499999996973, + "self_cpu_time_us": 109.79699999990407, + "cuda_time_us": 8.638000000501052, + "self_cuda_time_us": 8.638000000501052 + }, + { + "op": "void (anonymous namespace)::softmax_warp_forward(float*, float const*, int, int, int, bool const*, int, bool)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 8.638000000501052, + "self_cuda_time_us": 8.638000000501052 + }, + { + "op": "aten::add_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 99.12000000021362, + "self_cpu_time_us": 63.63799999993353, + "cuda_time_us": 8.605999999810592, + "self_cuda_time_us": 8.605999999810592 + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 8, + "cpu_time_us": 108.438999999722, + "self_cpu_time_us": 72.1019999996206, + "cuda_time_us": 8.412999999898602, + "self_cuda_time_us": 8.412999999898602 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 98.57599999988452, + "self_cpu_time_us": 61.18200000010256, + "cuda_time_us": 8.384000000398373, + "self_cuda_time_us": 8.384000000398373 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 20 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 88.97000000001572, + "self_cpu_time_us": 53.653000000005704, + "cuda_time_us": 8.093999999939115, + "self_cuda_time_us": 8.093999999939115 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 94.60199999973702, + "self_cpu_time_us": 62.96699999998964, + "cuda_time_us": 8.061999999874388, + "self_cuda_time_us": 8.061999999874388 + }, + { + "op": "aten::add_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 76.3810000000376, + "self_cpu_time_us": 43.827000000324915, + "cuda_time_us": 7.997000000003027, + "self_cuda_time_us": 7.997000000003027 + }, + { + "op": "at::native::(anonymous namespace)::masked_scatter_size_check(long const*, bool const*, long)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 7.64500000004773, + "self_cuda_time_us": 7.64500000004773 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 1200, + 2 + ], + [ + 1, + 1, + 1200, + 2 + ], + [] + ], + "count": 8, + "cpu_time_us": 131.0800000000454, + "self_cpu_time_us": 28.22000000020489, + "cuda_time_us": 7.518999999956577, + "self_cuda_time_us": 7.518999999956577 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456 + ], + [] + ], + "count": 8, + "cpu_time_us": 86.93499999995402, + "self_cpu_time_us": 46.43000000000757, + "cuda_time_us": 7.388999999835505, + "self_cuda_time_us": 7.388999999835505 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2 + ], + [] + ], + "count": 8, + "cpu_time_us": 94.52400000029593, + "self_cpu_time_us": 53.90900000005786, + "cuda_time_us": 7.039999999964493, + "self_cuda_time_us": 7.039999999964493 + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::FillFunctor, std::array, false>(int, at::native::FillFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 7.039999999964493, + "self_cuda_time_us": 7.039999999964493 + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 16, + "cpu_time_us": 102.34899999987647, + "self_cpu_time_us": 59.51999999970394, + "cuda_time_us": 7.0359999999491265, + "self_cuda_time_us": 7.0359999999491265 + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceScanInitKernel >(at_cuda_detail::cub::ScanTileState, int)", + "device_type": "DeviceType.CUDA", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 0, + "self_cpu_time_us": 0, + "cuda_time_us": 6.717999999920721, + "self_cuda_time_us": 6.717999999920721 + }, + { + "op": "cua.prepare", + "device_type": "DeviceType.CPU", + "is_user_annotation": true, + "input_shapes": [], + "count": 8, + "cpu_time_us": 57369.579, + "self_cpu_time_us": 27739.54000000006, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::lift_fresh", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 480, + 640, + 3 + ] + ], + "count": 8, + "cpu_time_us": 22.091999999991458, + "self_cpu_time_us": 22.091999999991458, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 480, + 640, + 3 + ], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 3.6520000000000437, + "self_cpu_time_us": 3.6520000000000437, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 480, + 640, + 3 + ], + [] + ], + "count": 8, + "cpu_time_us": 44.43999999999869, + "self_cpu_time_us": 44.43999999999869, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::permute", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 480, + 640, + 3 + ], + [] + ], + "count": 8, + "cpu_time_us": 91.1260000000002, + "self_cpu_time_us": 73.45400000000518, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 480, + 640, + 3 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 17.671999999995023, + "self_cpu_time_us": 17.671999999995023, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 480, + 640 + ], + [] + ], + "count": 16, + "cpu_time_us": 88.16300000000228, + "self_cpu_time_us": 72.68700000001263, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 480, + 640 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 15.475999999989654, + "self_cpu_time_us": 15.475999999989654, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 59.695000000008804, + "self_cpu_time_us": 52.15200000001096, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 7.542999999997846, + "self_cpu_time_us": 7.542999999997846, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 19655.899999999994, + "self_cpu_time_us": 25.659999999996217, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 19630.239999999998, + "self_cpu_time_us": 79.16900000000169, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::empty_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [], + [] + ], + "count": 8320, + "cpu_time_us": 33187.51700000135, + "self_cpu_time_us": 33187.51700000135, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [ + 1, + 3, + 480, + 640 + ], + [] + ], + "count": 8, + "cpu_time_us": 19512.894999999997, + "self_cpu_time_us": 19512.894999999997, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 34625.37500000023, + "self_cpu_time_us": 18.99900000001253, + "cuda_time_us": 2.6869999995687976, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [] + ], + "count": 24, + "cpu_time_us": 59.58300000005693, + "self_cpu_time_us": 59.58300000005693, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [ + 3, + 1, + 1 + ], + [] + ], + "count": 8, + "cpu_time_us": 2681.7650000000103, + "self_cpu_time_us": 2681.7650000000103, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::div_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [ + 3, + 1, + 1 + ] + ], + "count": 8, + "cpu_time_us": 1188.1819999999916, + "self_cpu_time_us": 1188.1819999999916, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [] + ], + "count": 8, + "cpu_time_us": 115.59600000000319, + "self_cpu_time_us": 76.47899999999936, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 480, + 640 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 39.11700000000383, + "self_cpu_time_us": 39.11700000000383, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::permute", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 15, + 2, + 16, + 20, + 2, + 16 + ], + [] + ], + "count": 8, + "cpu_time_us": 65.94900000000416, + "self_cpu_time_us": 47.79200000000856, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3, + 15, + 2, + 16, + 20, + 2, + 16 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 18.156999999995605, + "self_cpu_time_us": 18.156999999995605, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 16, + 16 + ], + [] + ], + "count": 8, + "cpu_time_us": 50.75199999999859, + "self_cpu_time_us": 37.30399999999827, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 16, + 16 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 13.44800000000032, + "self_cpu_time_us": 13.44800000000032, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 1, + 16, + 16 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 65.87799999999697, + "self_cpu_time_us": 54.749000000001615, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 1, + 16, + 16 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 11.128999999995358, + "self_cpu_time_us": 11.128999999995358, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 2, + 16, + 16 + ], + [] + ], + "count": 8, + "cpu_time_us": 4850.638999999992, + "self_cpu_time_us": 59.1620000000039, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 2, + 16, + 16 + ], + [] + ], + "count": 8, + "cpu_time_us": 4771.999999999989, + "self_cpu_time_us": 67.78199999998833, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 2, + 16, + 16 + ], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 123.28399999999783, + "self_cpu_time_us": 34.627999999993335, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::empty", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [], + [] + ], + "count": 7784, + "cpu_time_us": 29999.97799999576, + "self_cpu_time_us": 29999.97799999576, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 2, + 16, + 16 + ], + [ + 1, + 15, + 20, + 2, + 2, + 3, + 2, + 16, + 16 + ], + [] + ], + "count": 8, + "cpu_time_us": 4580.934000000003, + "self_cpu_time_us": 4580.934000000003, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 20, + 2, + 2, + 3, + 2, + 16, + 16 + ], + [] + ], + "count": 8, + "cpu_time_us": 19.476999999998952, + "self_cpu_time_us": 19.476999999998952, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 1536 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 47.67000000000917, + "self_cpu_time_us": 39.694000000001324, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 1536 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 7.9760000000078435, + "self_cpu_time_us": 7.9760000000078435, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 2.4499999999952706, + "self_cpu_time_us": 2.4499999999952706, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::lift_fresh", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ] + ], + "count": 8, + "cpu_time_us": 2.5670000000009168, + "self_cpu_time_us": 2.5670000000009168, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ] + ], + "count": 8, + "cpu_time_us": 25.33799999999428, + "self_cpu_time_us": 17.637000000002445, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ] + ], + "count": 8, + "cpu_time_us": 7.700999999991836, + "self_cpu_time_us": 7.700999999991836, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [], + [] + ], + "count": 80, + "cpu_time_us": 329.0749999998752, + "self_cpu_time_us": 281.1770000006891, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [], + [], + [] + ], + "count": 80, + "cpu_time_us": 47.89799999918614, + "self_cpu_time_us": 47.89799999918614, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::prod", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [] + ], + "count": 8, + "cpu_time_us": 133.08899999999085, + "self_cpu_time_us": 109.95799999999872, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [] + ], + "count": 56, + "cpu_time_us": 31.446999999658146, + "self_cpu_time_us": 31.446999999658146, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::item", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [] + ], + "count": 152, + "cpu_time_us": 2149.010000000657, + "self_cpu_time_us": 250.59399999952802, + "cuda_time_us": 137.8670000009879, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [], + [], + [], + [] + ], + "count": 32, + "cpu_time_us": 220.3129999999892, + "self_cpu_time_us": 21.61099999979524, + "cuda_time_us": 15.19799999964016, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::lift_fresh", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "count": 24, + "cpu_time_us": 6.034999999983484, + "self_cpu_time_us": 6.034999999983484, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "count": 24, + "cpu_time_us": 61.82599999998456, + "self_cpu_time_us": 47.62399999999252, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "count": 24, + "cpu_time_us": 14.20199999999204, + "self_cpu_time_us": 14.20199999999204, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_conj", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "count": 8, + "cpu_time_us": 3.4250000000047294, + "self_cpu_time_us": 3.4250000000047294, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "count": 8, + "cpu_time_us": 2.400999999985288, + "self_cpu_time_us": 2.400999999985288, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unbind", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "count": 16, + "cpu_time_us": 122.98099999998885, + "self_cpu_time_us": 59.99600000024475, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 178.7809999998335, + "self_cpu_time_us": 148.7100000000737, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [], + [] + ], + "count": 88, + "cpu_time_us": 52.47099999992861, + "self_cpu_time_us": 52.47099999992861, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_conj", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ] + ], + "count": 16, + "cpu_time_us": 3.69300000009207, + "self_cpu_time_us": 3.69300000009207, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ] + ], + "count": 16, + "cpu_time_us": 3.0630000002329325, + "self_cpu_time_us": 3.0630000002329325, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cua.transfer", + "device_type": "DeviceType.CPU", + "is_user_annotation": true, + "input_shapes": [], + "count": 8, + "cpu_time_us": 11492.1859999999, + "self_cpu_time_us": 744.3489999996236, + "cuda_time_us": 6275.142999999574, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 2901.6779999998253, + "self_cpu_time_us": 43.32900000020163, + "cuda_time_us": 10.97399999947811, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 56, + "cpu_time_us": 3519.100000000006, + "self_cpu_time_us": 267.21500000118976, + "cuda_time_us": 73.88199999985227, + "self_cuda_time_us": 0.0 + }, + { + "op": "Activity Buffer Request", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 12569.536000000226, + "self_cpu_time_us": 12569.536000000226, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaStreamIsCapturing", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 704, + "cpu_time_us": 359.7559999993391, + "self_cpu_time_us": 359.7559999993391, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaMemcpyAsync", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 1504, + "cpu_time_us": 24087.12299999973, + "self_cpu_time_us": 24087.12299999973, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaStreamSynchronize", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 848, + "cpu_time_us": 36168.8959999972, + "self_cpu_time_us": 36168.8959999972, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1536 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 7587.080000000307, + "self_cpu_time_us": 14.319000000323285, + "cuda_time_us": 6261.514000000243, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1536 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 7783.563000000067, + "self_cpu_time_us": 84.82200000069861, + "cuda_time_us": 6327.781000000177, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 462.44600000046194, + "self_cpu_time_us": 28.839000000341912, + "cuda_time_us": 11.838999999861699, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 433.60700000012, + "self_cpu_time_us": 69.40300000007846, + "cuda_time_us": 11.838999999861699, + "self_cuda_time_us": 0.0 + }, + { + "op": "cua.forward", + "device_type": "DeviceType.CPU", + "is_user_annotation": true, + "input_shapes": [], + "count": 8, + "cpu_time_us": 1786880.8800000001, + "self_cpu_time_us": 7978.540999999823, + "cuda_time_us": 649845.7019999725, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::embedding", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320, + 2560 + ], + [ + 1, + 456 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 734.7579999996524, + "self_cpu_time_us": 79.61499999964144, + "cuda_time_us": 20.541999999899417, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "count": 8, + "cpu_time_us": 32.0269999999291, + "self_cpu_time_us": 16.44399999997404, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "count": 8, + "cpu_time_us": 15.582999999955064, + "self_cpu_time_us": 15.582999999955064, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::index_select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320, + 2560 + ], + [], + [ + 456 + ] + ], + "count": 8, + "cpu_time_us": 618.0719999998983, + "self_cpu_time_us": 156.9259999996284, + "cuda_time_us": 20.541999999899417, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::resize_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ], + [], + [] + ], + "count": 1520, + "cpu_time_us": 5196.395999999062, + "self_cpu_time_us": 5196.395999999062, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [] + ], + "count": 32, + "cpu_time_us": 22.59100000014587, + "self_cpu_time_us": 22.59100000014587, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 1 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 43.41100000006554, + "self_cpu_time_us": 29.671000000162167, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 1 + ], + [], + [], + [] + ], + "count": 32, + "cpu_time_us": 23.54300000028161, + "self_cpu_time_us": 23.54300000028161, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 4.756999999881373, + "self_cpu_time_us": 4.756999999881373, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320, + 2560 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 13.670999999914784, + "self_cpu_time_us": 13.670999999914784, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaLaunchKernel", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 55072, + "cpu_time_us": 251898.1059999841, + "self_cpu_time_us": 249988.98299998397, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [] + ], + "count": 8, + "cpu_time_us": 5.044000000183587, + "self_cpu_time_us": 5.044000000183587, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1536 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 227.58400000017718, + "self_cpu_time_us": 16.78200000009383, + "cuda_time_us": 66.26699999993434, + "self_cuda_time_us": 0.0 + }, + { + "op": "cua.vision", + "device_type": "DeviceType.CPU", + "is_user_annotation": true, + "input_shapes": [], + "count": 8, + "cpu_time_us": 291374.7289999998, + "self_cpu_time_us": 85138.44799999941, + "cuda_time_us": 110231.97500000036, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::repeat_interleave", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [ + 1 + ], + [], + [] + ], + "count": 32, + "cpu_time_us": 5781.712999999712, + "self_cpu_time_us": 302.10099999967497, + "cuda_time_us": 318.22499999939464, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::flatten", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [] + ], + "count": 32, + "cpu_time_us": 10.130999999659252, + "self_cpu_time_us": 10.130999999659252, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 32, + "cpu_time_us": 88.67199999988952, + "self_cpu_time_us": 42.75900000031106, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 72, + "cpu_time_us": 74.78699999950186, + "self_cpu_time_us": 74.78699999950186, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [] + ], + "count": 40, + "cpu_time_us": 145.51399999995192, + "self_cpu_time_us": 124.31399999953283, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 68.92999999974563, + "self_cpu_time_us": 68.92999999974563, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 185.35199999986799, + "self_cpu_time_us": 24.213999999585212, + "cuda_time_us": 9.951000000321073, + "self_cuda_time_us": 0.0 + }, + { + "op": "cudaPeekAtLastError", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 384, + "cpu_time_us": 38.675999999963096, + "self_cpu_time_us": 38.675999999963096, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 56, + "cpu_time_us": 94.83899999926507, + "self_cpu_time_us": 94.83899999926507, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaDeviceGetAttribute", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 696, + "cpu_time_us": 517.5590000006341, + "self_cpu_time_us": 517.5590000006341, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [] + ], + "count": 32, + "cpu_time_us": 82.59400000078313, + "self_cpu_time_us": 65.2160000011936, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::all", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ] + ], + "count": 32, + "cpu_time_us": 688.0350000003673, + "self_cpu_time_us": 266.24100000182807, + "cuda_time_us": 30.395000000164146, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view_as", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 32, + "cpu_time_us": 60.330999999147025, + "self_cpu_time_us": 44.52999999909662, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [] + ], + "count": 40, + "cpu_time_us": 8.64899999955378, + "self_cpu_time_us": 8.64899999955378, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::index_select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [ + 1200 + ] + ], + "count": 24, + "cpu_time_us": 805.7770000004239, + "self_cpu_time_us": 258.652999999671, + "cuda_time_us": 65.81599999958416, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [] + ], + "count": 808, + "cpu_time_us": 450.01099999838334, + "self_cpu_time_us": 450.01099999838334, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 52.2460000004794, + "self_cpu_time_us": 41.75200000083714, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [], + [], + [] + ], + "count": 112, + "cpu_time_us": 47.21899999929883, + "self_cpu_time_us": 47.21899999929883, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 75.52900000003865, + "self_cpu_time_us": 66.40299999990384, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::pad", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 273.0839999997843, + "self_cpu_time_us": 27.759999999718275, + "cuda_time_us": 7.0359999999491265, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::constant_pad_nd", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 245.324000000066, + "self_cpu_time_us": 68.1439999997965, + "cuda_time_us": 7.0359999999491265, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 42.511999999856926, + "self_cpu_time_us": 22.73099999994156, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ], + [ + 0 + ], + [] + ], + "count": 136, + "cpu_time_us": 132.22199999868462, + "self_cpu_time_us": 132.22199999868462, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::arange", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [] + ], + "count": 72, + "cpu_time_us": 1419.9350000004197, + "self_cpu_time_us": 230.1250000004511, + "cuda_time_us": 54.52299999947718, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 655.1420000004146, + "self_cpu_time_us": 51.01100000052247, + "cuda_time_us": 63.00299999945855, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 32, + "cpu_time_us": 604.1309999998921, + "self_cpu_time_us": 149.07400000029884, + "cuda_time_us": 63.00299999945855, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::arange", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 295.4169999999431, + "self_cpu_time_us": 52.897999999986496, + "cuda_time_us": 13.885999999940395, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200 + ], + [] + ], + "count": 64, + "cpu_time_us": 168.77400000070338, + "self_cpu_time_us": 139.8670000009006, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [], + [], + [] + ], + "count": 32, + "cpu_time_us": 11.301999999705004, + "self_cpu_time_us": 11.301999999705004, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::abs", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ] + ], + "count": 16, + "cpu_time_us": 373.21099999967555, + "self_cpu_time_us": 75.45999999978812, + "cuda_time_us": 16.413000000218744, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::rsub", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [] + ], + "count": 16, + "cpu_time_us": 275.58700000017416, + "self_cpu_time_us": 61.18200000017532, + "cuda_time_us": 16.441999999951804, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [] + ], + "count": 40, + "cpu_time_us": 104.03300000044692, + "self_cpu_time_us": 85.25700000092911, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [], + [] + ], + "count": 72, + "cpu_time_us": 36.52299999918614, + "self_cpu_time_us": 36.52299999918614, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 2 + ], + [] + ], + "count": 16, + "cpu_time_us": 51.16799999999057, + "self_cpu_time_us": 25.523000000044703, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 2 + ], + [] + ], + "count": 16, + "cpu_time_us": 25.644999999945867, + "self_cpu_time_us": 25.644999999945867, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 429.68900000043504, + "self_cpu_time_us": 25.636000000857166, + "cuda_time_us": 5.407000000210246, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 616, + "cpu_time_us": 13219.991999998456, + "self_cpu_time_us": 1824.5389999976614, + "cuda_time_us": 591.9800000009127, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::lift_fresh", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ] + ], + "count": 16, + "cpu_time_us": 6.0140000008104835, + "self_cpu_time_us": 6.0140000008104835, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ] + ], + "count": 16, + "cpu_time_us": 45.99199999998382, + "self_cpu_time_us": 27.734999999360298, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ] + ], + "count": 16, + "cpu_time_us": 18.25700000062352, + "self_cpu_time_us": 18.25700000062352, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_conj", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ] + ], + "count": 8, + "cpu_time_us": 2.977000000231783, + "self_cpu_time_us": 2.977000000231783, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ] + ], + "count": 8, + "cpu_time_us": 1.89200000022538, + "self_cpu_time_us": 1.89200000022538, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_conj", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ] + ], + "count": 592, + "cpu_time_us": 109.2970000012283, + "self_cpu_time_us": 109.2970000012283, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ] + ], + "count": 592, + "cpu_time_us": 87.83200000115903, + "self_cpu_time_us": 87.83200000115903, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 592, + "cpu_time_us": 13368.108999998643, + "self_cpu_time_us": 713.3080000000482, + "cuda_time_us": 576.6220000003814, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::meshgrid", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 16, + "cpu_time_us": 311.9370000004128, + "self_cpu_time_us": 146.19900000044436, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 30 + ], + [] + ], + "count": 8, + "cpu_time_us": 11.638999999806401, + "self_cpu_time_us": 11.638999999806401, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 30, + 1 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 31.461000000068452, + "self_cpu_time_us": 25.08800000025076, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 30, + 1 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 6.372999999817694, + "self_cpu_time_us": 6.372999999817694, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 40 + ], + [] + ], + "count": 8, + "cpu_time_us": 6.829000000201631, + "self_cpu_time_us": 6.829000000201631, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 40 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 20.571000000083586, + "self_cpu_time_us": 16.521999999895343, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 40 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 4.049000000188244, + "self_cpu_time_us": 4.049000000188244, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 30, + 40 + ], + [] + ], + "count": 16, + "cpu_time_us": 122.7209999999759, + "self_cpu_time_us": 89.3700000000681, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 30, + 40 + ], + [], + [] + ], + "count": 16, + "cpu_time_us": 33.3509999999078, + "self_cpu_time_us": 33.3509999999078, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15, + 2, + 20, + 2 + ], + [], + [] + ], + "count": 16, + "cpu_time_us": 66.75699999961944, + "self_cpu_time_us": 54.453999999706866, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15, + 2, + 20, + 2 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 12.302999999912572, + "self_cpu_time_us": 12.302999999912572, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::flatten", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15, + 20, + 2, + 2 + ], + [], + [] + ], + "count": 16, + "cpu_time_us": 443.922999999646, + "self_cpu_time_us": 62.20799999940209, + "cuda_time_us": 22.076999999946565, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15, + 20, + 2, + 2 + ], + [] + ], + "count": 16, + "cpu_time_us": 362.6879999999219, + "self_cpu_time_us": 63.253999998938525, + "cuda_time_us": 22.076999999946565, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15, + 20, + 2, + 2 + ], + [], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 106.19600000050559, + "self_cpu_time_us": 30.1250000007567, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15, + 20, + 2, + 2 + ], + [] + ], + "count": 16, + "cpu_time_us": 19.027000000322005, + "self_cpu_time_us": 19.027000000322005, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::stack", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 16, + "cpu_time_us": 451.0090000002383, + "self_cpu_time_us": 104.34199999996054, + "cuda_time_us": 29.050999999861233, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::repeat", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [] + ], + "count": 8, + "cpu_time_us": 831.6680000000924, + "self_cpu_time_us": 177.82399999939662, + "cuda_time_us": 7.518999999956577, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [] + ], + "count": 16, + "cpu_time_us": 37.974000000584056, + "self_cpu_time_us": 29.838000000687316, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unfold", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 24.4159999997064, + "self_cpu_time_us": 18.66099999997823, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unfold", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 2, + 1200 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 18.228000000104657, + "self_cpu_time_us": 13.936000000190688, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 2, + 1200 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 4.291999999913969, + "self_cpu_time_us": 4.291999999913969, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand_as", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [ + 1, + 1, + 1200, + 2 + ] + ], + "count": 8, + "cpu_time_us": 33.797000000136904, + "self_cpu_time_us": 15.900999999750638, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 69.44700000010198, + "self_cpu_time_us": 69.44700000010198, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2 + ], + [] + ], + "count": 16, + "cpu_time_us": 36.65700000047218, + "self_cpu_time_us": 23.595000000248547, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2 + ], + [], + [], + [] + ], + "count": 408, + "cpu_time_us": 210.81799999886425, + "self_cpu_time_us": 210.81799999886425, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2, + 2 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 52.07100000009814, + "self_cpu_time_us": 25.12899999995716, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2, + 2 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 26.94200000014098, + "self_cpu_time_us": 21.913000000204192, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2, + 2 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 5.0289999999367865, + "self_cpu_time_us": 5.0289999999367865, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::flatten", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2, + 2 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 18.471999999848776, + "self_cpu_time_us": 12.169999999838183, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2, + 2 + ], + [] + ], + "count": 8, + "cpu_time_us": 6.302000000010594, + "self_cpu_time_us": 6.302000000010594, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::permute", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 1200, + 2 + ], + [] + ], + "count": 8, + "cpu_time_us": 22.364000000117812, + "self_cpu_time_us": 18.494000000093365, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 1200, + 2 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 3.870000000024447, + "self_cpu_time_us": 3.870000000024447, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 1, + 2 + ], + [] + ], + "count": 8, + "cpu_time_us": 13.339999999763677, + "self_cpu_time_us": 8.637999999933527, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 1, + 2 + ], + [] + ], + "count": 8, + "cpu_time_us": 4.70199999983015, + "self_cpu_time_us": 4.70199999983015, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 28.446000000083586, + "self_cpu_time_us": 10.61000000021886, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 17.835999999864725, + "self_cpu_time_us": 13.979999999821302, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::pad", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 325.6130000000412, + "self_cpu_time_us": 24.322000000072876, + "cuda_time_us": 14.399000000106753, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::constant_pad_nd", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 301.29099999996834, + "self_cpu_time_us": 64.39799999943352, + "cuda_time_us": 14.399000000106753, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 38.660000000032596, + "self_cpu_time_us": 14.664000000237138, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2 + ], + [], + [], + [], + [] + ], + "count": 392, + "cpu_time_us": 1210.4219999991037, + "self_cpu_time_us": 1012.6660000004631, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1536 + ], + [] + ], + "count": 8, + "cpu_time_us": 19.645000000164146, + "self_cpu_time_us": 19.645000000164146, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3, + 2, + 16, + 16 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 3.468000000269967, + "self_cpu_time_us": 3.468000000269967, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::conv3d", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3, + 2, + 16, + 16 + ], + [ + 1024, + 3, + 2, + 16, + 16 + ], + [ + 1024 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 1456.9119999999675, + "self_cpu_time_us": 38.50599999996484, + "cuda_time_us": 6721.9109999997745, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::convolution", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3, + 2, + 16, + 16 + ], + [ + 1024, + 3, + 2, + 16, + 16 + ], + [ + 1024 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 1418.4060000000027, + "self_cpu_time_us": 64.54699999965669, + "cuda_time_us": 6721.9109999997745, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_convolution", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3, + 2, + 16, + 16 + ], + [ + 1024, + 3, + 2, + 16, + 16 + ], + [ + 1024 + ], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 1353.859000000346, + "self_cpu_time_us": 121.48700000059034, + "cuda_time_us": 6721.9109999997745, + "self_cuda_time_us": 0.0 + }, + { + "op": "cudaMemsetAsync", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 1568, + "cpu_time_us": 7805.604999997973, + "self_cpu_time_us": 7805.604999997973, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaGetErrorString", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 32, + "cpu_time_us": 6.008999999903608, + "self_cpu_time_us": 6.008999999903608, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaFuncGetAttributes", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 66.64700000028824, + "self_cpu_time_us": 66.64700000028824, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaLaunchKernelExC", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 1816, + "cpu_time_us": 8409.597000001813, + "self_cpu_time_us": 8409.597000001813, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024 + ], + [] + ], + "count": 8, + "cpu_time_us": 19.960999999952037, + "self_cpu_time_us": 11.918999999921652, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024 + ], + [] + ], + "count": 8, + "cpu_time_us": 8.042000000030384, + "self_cpu_time_us": 8.042000000030384, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024, + 1, + 1, + 1 + ], + [] + ], + "count": 8, + "cpu_time_us": 13.063000000285683, + "self_cpu_time_us": 13.063000000285683, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::embedding", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2304, + 1024 + ], + [ + 1200, + 4 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 403.9340000000375, + "self_cpu_time_us": 51.35400000044319, + "cuda_time_us": 61.39999999979045, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4 + ], + [] + ], + "count": 8, + "cpu_time_us": 13.223999999681837, + "self_cpu_time_us": 9.229999999617576, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4 + ], + [] + ], + "count": 8, + "cpu_time_us": 3.9940000000642613, + "self_cpu_time_us": 3.9940000000642613, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::index_select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2304, + 1024 + ], + [], + [ + 4800 + ] + ], + "count": 8, + "cpu_time_us": 334.96300000004703, + "self_cpu_time_us": 101.16000000108033, + "cuda_time_us": 61.39999999979045, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4800 + ], + [] + ], + "count": 8, + "cpu_time_us": 4.388999999544467, + "self_cpu_time_us": 4.388999999544467, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4800, + 1 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 21.0919999996986, + "self_cpu_time_us": 15.693999999639345, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4800, + 1 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 5.398000000059255, + "self_cpu_time_us": 5.398000000059255, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4800, + 1024 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 3.0539999999455176, + "self_cpu_time_us": 3.0539999999455176, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2304, + 1024 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 3.365999999543419, + "self_cpu_time_us": 3.365999999543419, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4800, + 1024 + ], + [] + ], + "count": 8, + "cpu_time_us": 4.392999999865424, + "self_cpu_time_us": 4.392999999865424, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4 + ], + [] + ], + "count": 8, + "cpu_time_us": 31.396999999677064, + "self_cpu_time_us": 27.893999999621883, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 3.503000000055181, + "self_cpu_time_us": 3.503000000055181, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 4.543999999819789, + "self_cpu_time_us": 4.543999999819789, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [], + [], + [] + ], + "count": 392, + "cpu_time_us": 7526.929000000906, + "self_cpu_time_us": 602.7550000002084, + "cuda_time_us": 1297.5050000019837, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 392, + "cpu_time_us": 6924.174000000698, + "self_cpu_time_us": 1533.8569999972096, + "cuda_time_us": 1297.5050000019837, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 161.6449999999022, + "self_cpu_time_us": 10.936999999903492, + "cuda_time_us": 16.157999999821186, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 150.70799999999872, + "self_cpu_time_us": 30.359999999796855, + "cuda_time_us": 16.157999999821186, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 3.1539999999076826, + "self_cpu_time_us": 3.1539999999076826, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 16 + ], + [], + [] + ], + "count": 32, + "cpu_time_us": 114.87100000015926, + "self_cpu_time_us": 97.23000000040338, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 2, + 16 + ], + [], + [], + [] + ], + "count": 32, + "cpu_time_us": 17.640999999755877, + "self_cpu_time_us": 17.640999999755877, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [] + ], + "count": 8, + "cpu_time_us": 26.065000000045984, + "self_cpu_time_us": 13.057000000204425, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [] + ], + "count": 16, + "cpu_time_us": 26.656000000060885, + "self_cpu_time_us": 26.656000000060885, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::layer_norm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [ + 1024 + ], + [ + 1024 + ], + [], + [] + ], + "count": 392, + "cpu_time_us": 13484.004000002824, + "self_cpu_time_us": 1655.9480000029143, + "cuda_time_us": 1737.8029999991122, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 3072, + 1024 + ], + [ + 3072 + ] + ], + "count": 192, + "cpu_time_us": 5455.549000000436, + "self_cpu_time_us": 508.23300000101153, + "cuda_time_us": 10775.203000000198, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3072, + 1024 + ] + ], + "count": 192, + "cpu_time_us": 733.7849999988539, + "self_cpu_time_us": 327.4699999978475, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3072, + 1024 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 406.3150000010064, + "self_cpu_time_us": 319.41100000154984, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3072, + 1024 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 86.90399999945657, + "self_cpu_time_us": 86.90399999945657, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaOccupancyMaxActiveBlocksPerMultiprocessor", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 2200, + "cpu_time_us": 2326.657000002815, + "self_cpu_time_us": 2326.657000002815, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3072 + ], + [] + ], + "count": 192, + "cpu_time_us": 700.1559999995807, + "self_cpu_time_us": 341.77299999912793, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3072 + ], + [] + ], + "count": 192, + "cpu_time_us": 358.38300000045274, + "self_cpu_time_us": 358.38300000045274, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::permute", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3, + 16, + 64 + ], + [] + ], + "count": 192, + "cpu_time_us": 943.9699999987788, + "self_cpu_time_us": 791.7929999985354, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 3, + 16, + 64 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 152.17700000024342, + "self_cpu_time_us": 152.17700000024342, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unbind", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1200, + 16, + 64 + ], + [] + ], + "count": 192, + "cpu_time_us": 2894.5030000011466, + "self_cpu_time_us": 1218.9630000021425, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1200, + 16, + 64 + ], + [], + [] + ], + "count": 576, + "cpu_time_us": 1675.539999999004, + "self_cpu_time_us": 1312.1789999995526, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1200, + 16, + 64 + ], + [], + [], + [] + ], + "count": 576, + "cpu_time_us": 363.36099999945145, + "self_cpu_time_us": 363.36099999945145, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [], + [], + [], + [] + ], + "count": 768, + "cpu_time_us": 14128.285000000978, + "self_cpu_time_us": 995.2490000032994, + "cuda_time_us": 2942.563999998296, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 768, + "cpu_time_us": 13133.035999997679, + "self_cpu_time_us": 3016.3459999965417, + "cuda_time_us": 2942.563999998296, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 64 + ], + [] + ], + "count": 384, + "cpu_time_us": 1235.4539999991975, + "self_cpu_time_us": 1032.4269999983371, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 64 + ], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 203.02700000086043, + "self_cpu_time_us": 203.02700000086043, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1, + 64 + ], + [], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 125.73399999867252, + "self_cpu_time_us": 125.73399999867252, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [], + [], + [], + [] + ], + "count": 768, + "cpu_time_us": 2712.6600000024773, + "self_cpu_time_us": 2316.4290000018664, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [], + [], + [] + ], + "count": 1344, + "cpu_time_us": 714.7220000026864, + "self_cpu_time_us": 714.7220000026864, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [], + [] + ], + "count": 576, + "cpu_time_us": 1667.5999999990454, + "self_cpu_time_us": 1349.10899999697, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 1200, + 64 + ], + [] + ], + "count": 576, + "cpu_time_us": 1545.8300000008458, + "self_cpu_time_us": 1219.0360000007931, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 1200, + 64 + ], + [], + [], + [] + ], + "count": 576, + "cpu_time_us": 326.7940000000526, + "self_cpu_time_us": 326.7940000000526, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::split_with_sizes", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 1200, + 64 + ], + [], + [] + ], + "count": 576, + "cpu_time_us": 2017.2250000018103, + "self_cpu_time_us": 1653.740999999427, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 1200, + 64 + ], + [], + [], + [] + ], + "count": 1344, + "cpu_time_us": 736.1150000013004, + "self_cpu_time_us": 736.1150000013004, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::scaled_dot_product_attention", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 1200, + 64 + ], + [ + 1, + 16, + 1200, + 64 + ], + [ + 1, + 16, + 1200, + 64 + ], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 14504.386999998693, + "self_cpu_time_us": 2293.059999998528, + "cuda_time_us": 14417.785999999513, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_scaled_dot_product_flash_attention", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 1200, + 64 + ], + [ + 1, + 16, + 1200, + 64 + ], + [ + 1, + 16, + 1200, + 64 + ], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 12211.327000000165, + "self_cpu_time_us": 1713.198000001139, + "cuda_time_us": 14417.785999999513, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 1200, + 64 + ], + [], + [] + ], + "count": 768, + "cpu_time_us": 1865.8190000014438, + "self_cpu_time_us": 1493.1880000025267, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 1298.2560000013618, + "self_cpu_time_us": 395.5300000000425, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaFuncSetAttribute", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 256, + "cpu_time_us": 770.5769999995973, + "self_cpu_time_us": 770.5769999995973, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 437.02099999981874, + "self_cpu_time_us": 325.4940000010247, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 210.1819999988511, + "self_cpu_time_us": 210.1819999988511, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 951.4240000012942, + "self_cpu_time_us": 480.1459999999206, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 471.2780000013736, + "self_cpu_time_us": 372.62300000131654, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [] + ], + "count": 192, + "cpu_time_us": 746.7770000017626, + "self_cpu_time_us": 339.96900000204914, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [] + ], + "count": 192, + "cpu_time_us": 406.8079999997135, + "self_cpu_time_us": 406.8079999997135, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 1024, + 1024 + ], + [ + 1024 + ] + ], + "count": 192, + "cpu_time_us": 8672.342999998174, + "self_cpu_time_us": 668.3429999965447, + "cuda_time_us": 4498.1020000008575, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 1024 + ] + ], + "count": 192, + "cpu_time_us": 877.7050000016752, + "self_cpu_time_us": 459.90500000129396, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 1024 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 417.80000000038126, + "self_cpu_time_us": 333.95400000171503, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 1024 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 83.84599999866623, + "self_cpu_time_us": 83.84599999866623, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cuLaunchKernel", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 648, + "cpu_time_us": 2826.1079999987414, + "self_cpu_time_us": 2826.1079999987414, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 4096, + 1024 + ], + [ + 4096 + ] + ], + "count": 192, + "cpu_time_us": 5630.40400000017, + "self_cpu_time_us": 503.7509999977483, + "cuda_time_us": 14826.538999999219, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 1024 + ] + ], + "count": 192, + "cpu_time_us": 767.9830000010552, + "self_cpu_time_us": 343.95300000315183, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 1024 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 424.02999999790336, + "self_cpu_time_us": 340.61899999809975, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 1024 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 83.41099999980361, + "self_cpu_time_us": 83.41099999980361, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 69.34100000008766, + "self_cpu_time_us": 69.34100000008766, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 16, + 1024 + ], + [] + ], + "count": 192, + "cpu_time_us": 7485.3329999999405, + "self_cpu_time_us": 548.1539999999804, + "cuda_time_us": 1598.9739999996818, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 1024 + ] + ], + "count": 192, + "cpu_time_us": 774.4449999996577, + "self_cpu_time_us": 313.88299999941955, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 1024 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 460.5620000002382, + "self_cpu_time_us": 360.1639999987965, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 1024 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 100.39800000144169, + "self_cpu_time_us": 100.39800000144169, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 1024, + 16 + ] + ], + "count": 192, + "cpu_time_us": 6162.734000000302, + "self_cpu_time_us": 372.35700000172073, + "cuda_time_us": 1598.9739999996818, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 4096, + 16 + ], + [] + ], + "count": 192, + "cpu_time_us": 4408.582999999417, + "self_cpu_time_us": 428.26899999823945, + "cuda_time_us": 2419.377999999604, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 16 + ] + ], + "count": 200, + "cpu_time_us": 724.5900000014954, + "self_cpu_time_us": 297.388000000763, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 16 + ], + [], + [] + ], + "count": 200, + "cpu_time_us": 427.20200000073237, + "self_cpu_time_us": 336.0850000015198, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 16 + ], + [], + [], + [] + ], + "count": 200, + "cpu_time_us": 91.11699999921257, + "self_cpu_time_us": 91.11699999921257, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 16, + 4096 + ] + ], + "count": 192, + "cpu_time_us": 3282.7419999999984, + "self_cpu_time_us": 243.46199999972305, + "cuda_time_us": 2419.377999999604, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 7189.647999998633, + "self_cpu_time_us": 575.5409999986005, + "cuda_time_us": 3623.8999999991356, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 6614.107000000033, + "self_cpu_time_us": 1459.433000001809, + "cuda_time_us": 3623.8999999991356, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 1024, + 4096 + ], + [ + 1024 + ] + ], + "count": 192, + "cpu_time_us": 6257.053999999189, + "self_cpu_time_us": 517.5779999985389, + "cuda_time_us": 15736.064000000653, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 4096 + ] + ], + "count": 192, + "cpu_time_us": 809.0540000012697, + "self_cpu_time_us": 346.8490000019083, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 4096 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 462.20499999936146, + "self_cpu_time_us": 359.60799999776646, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 4096 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 102.597000001595, + "self_cpu_time_us": 102.597000001595, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 43.489000001136446, + "self_cpu_time_us": 43.489000001136446, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 16, + 4096 + ], + [] + ], + "count": 192, + "cpu_time_us": 5664.83899999912, + "self_cpu_time_us": 419.8250000004482, + "cuda_time_us": 2974.108999999051, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 4096 + ] + ], + "count": 272, + "cpu_time_us": 1105.8689999979688, + "self_cpu_time_us": 457.54799999966053, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 4096 + ], + [], + [] + ], + "count": 272, + "cpu_time_us": 648.3209999983083, + "self_cpu_time_us": 508.7539999977016, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 4096 + ], + [], + [], + [] + ], + "count": 272, + "cpu_time_us": 139.56700000060664, + "self_cpu_time_us": 139.56700000060664, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 4096, + 16 + ] + ], + "count": 192, + "cpu_time_us": 4516.114000001209, + "self_cpu_time_us": 265.3860000017885, + "cuda_time_us": 2974.108999999051, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 1024, + 16 + ], + [] + ], + "count": 192, + "cpu_time_us": 4161.748000000487, + "self_cpu_time_us": 387.2899999996589, + "cuda_time_us": 867.5939999995026, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 16 + ] + ], + "count": 320, + "cpu_time_us": 1125.3400000004913, + "self_cpu_time_us": 454.62699999949837, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 16 + ], + [], + [] + ], + "count": 320, + "cpu_time_us": 670.7130000009929, + "self_cpu_time_us": 529.43400000158, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 16 + ], + [], + [], + [] + ], + "count": 320, + "cpu_time_us": 141.27899999941292, + "self_cpu_time_us": 141.27899999941292, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 16, + 1024 + ] + ], + "count": 192, + "cpu_time_us": 3107.5269999999, + "self_cpu_time_us": 238.49100000027101, + "cuda_time_us": 867.5939999995026, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 4096, + 4096 + ], + [ + 4096 + ] + ], + "count": 8, + "cpu_time_us": 243.8329999995767, + "self_cpu_time_us": 19.0239999996993, + "cuda_time_us": 708.2089999999152, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 4096 + ] + ], + "count": 8, + "cpu_time_us": 32.840999999971245, + "self_cpu_time_us": 15.897999999986496, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 4096 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 16.94299999998475, + "self_cpu_time_us": 13.419999999983702, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 4096 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 3.5230000000010477, + "self_cpu_time_us": 3.5230000000010477, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 470.4869999997027, + "self_cpu_time_us": 33.187000000165426, + "cuda_time_us": 86.64499999961117, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 437.29999999953725, + "self_cpu_time_us": 120.66499999896041, + "cuda_time_us": 86.64499999961117, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [], + [] + ], + "count": 16, + "cpu_time_us": 3.2359999996988336, + "self_cpu_time_us": 3.2359999996988336, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 16, + 4096 + ], + [] + ], + "count": 16, + "cpu_time_us": 464.46699999971315, + "self_cpu_time_us": 32.465999999622, + "cuda_time_us": 138.06499999990046, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 4096, + 16 + ] + ], + "count": 16, + "cpu_time_us": 376.0449999996781, + "self_cpu_time_us": 21.112999999706517, + "cuda_time_us": 138.06499999990046, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 4096, + 16 + ], + [] + ], + "count": 8, + "cpu_time_us": 172.70099999969534, + "self_cpu_time_us": 15.91999999928521, + "cuda_time_us": 36.79499999980908, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 16, + 4096 + ] + ], + "count": 8, + "cpu_time_us": 129.7630000000936, + "self_cpu_time_us": 9.669000000169035, + "cuda_time_us": 36.79499999980908, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 2560, + 4096 + ], + [ + 2560 + ] + ], + "count": 8, + "cpu_time_us": 234.9009999997361, + "self_cpu_time_us": 18.78099999965343, + "cuda_time_us": 499.1120000000665, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 4096 + ] + ], + "count": 264, + "cpu_time_us": 1532.706999998336, + "self_cpu_time_us": 757.5969999979861, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 4096 + ], + [], + [] + ], + "count": 264, + "cpu_time_us": 775.1100000003498, + "self_cpu_time_us": 583.3179999993299, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 4096 + ], + [], + [], + [] + ], + "count": 264, + "cpu_time_us": 191.79200000101991, + "self_cpu_time_us": 191.79200000101991, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 2560, + 16 + ], + [] + ], + "count": 8, + "cpu_time_us": 169.62900000014633, + "self_cpu_time_us": 15.10200000036275, + "cuda_time_us": 28.702000000077533, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 16 + ] + ], + "count": 328, + "cpu_time_us": 1206.8059999978723, + "self_cpu_time_us": 460.21499999592197, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 16 + ], + [], + [] + ], + "count": 328, + "cpu_time_us": 746.5910000019503, + "self_cpu_time_us": 594.6899999988382, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 16 + ], + [], + [], + [] + ], + "count": 328, + "cpu_time_us": 151.90100000311213, + "self_cpu_time_us": 151.90100000311213, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 16, + 2560 + ] + ], + "count": 8, + "cpu_time_us": 128.74699999963923, + "self_cpu_time_us": 11.681999999622349, + "cuda_time_us": 28.702000000077533, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 135.7149999999383, + "self_cpu_time_us": 10.452999999921303, + "cuda_time_us": 14.430999999676715, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 125.262000000017, + "self_cpu_time_us": 25.716000000422355, + "cuda_time_us": 14.430999999676715, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::split_with_sizes", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 47.176999999705004, + "self_cpu_time_us": 40.67299999957322, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 10.765000000159489, + "self_cpu_time_us": 10.765000000159489, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 50.67299999999523, + "self_cpu_time_us": 26.863000000055763, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 23.809999999939464, + "self_cpu_time_us": 19.548999999911757, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 5.70999999975902, + "self_cpu_time_us": 5.70999999975902, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 498.02299999997194, + "self_cpu_time_us": 35.9739999997837, + "cuda_time_us": 47.710000000734, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "count": 16, + "cpu_time_us": 67.33000000000175, + "self_cpu_time_us": 57.24899999976333, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 7.690999999613268, + "self_cpu_time_us": 7.690999999613268, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::detach", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [] + ], + "count": 8, + "cpu_time_us": 44.394000000014785, + "self_cpu_time_us": 17.527999999845633, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "detach", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [] + ], + "count": 8, + "cpu_time_us": 26.86600000016915, + "self_cpu_time_us": 26.86600000016915, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_is_all_true", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [] + ], + "count": 8, + "cpu_time_us": 218.68400000040128, + "self_cpu_time_us": 19.878000000084285, + "cuda_time_us": 8.44700000002922, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::all", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [] + ], + "count": 8, + "cpu_time_us": 198.806000000317, + "self_cpu_time_us": 74.72100000065984, + "cuda_time_us": 8.44700000002922, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view_as", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 8, + "cpu_time_us": 26.631000000081258, + "self_cpu_time_us": 17.735000000247965, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [] + ], + "count": 8, + "cpu_time_us": 8.895999999833293, + "self_cpu_time_us": 8.895999999833293, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::masked_scatter", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 1 + ], + [ + 300, + 2560 + ] + ], + "count": 8, + "cpu_time_us": 1026.8570000001491, + "self_cpu_time_us": 98.73100000034901, + "cuda_time_us": 162.18700000061654, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 25.844999999681022, + "self_cpu_time_us": 21.5609999995213, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 4.284000000159722, + "self_cpu_time_us": 4.284000000159722, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 17.520999999775086, + "self_cpu_time_us": 12.204000000070664, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 5.3169999997044215, + "self_cpu_time_us": 5.3169999997044215, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 16, + "cpu_time_us": 327.1100000000297, + "self_cpu_time_us": 46.53800000039337, + "cuda_time_us": 52.44200000050478, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 93.4719999996596, + "self_cpu_time_us": 27.23699999920791, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::contiguous", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 8, + "cpu_time_us": 166.13800000002084, + "self_cpu_time_us": 11.172000000224216, + "cuda_time_us": 22.267000000414555, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::zeros", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [] + ], + "count": 392, + "cpu_time_us": 8908.739000000642, + "self_cpu_time_us": 1796.9290000001638, + "cuda_time_us": 469.2869999992545, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::zero_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456 + ] + ], + "count": 8, + "cpu_time_us": 114.94200000035926, + "self_cpu_time_us": 28.00700000040524, + "cuda_time_us": 7.388999999835505, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::unbind", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 3 + ], + [] + ], + "count": 8, + "cpu_time_us": 72.14199999996345, + "self_cpu_time_us": 34.88499999968917, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 474.69699999968, + "self_cpu_time_us": 34.60999999989872, + "cuda_time_us": 49.721999999528634, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 32, + "cpu_time_us": 629.7160000000586, + "self_cpu_time_us": 115.68999999972584, + "cuda_time_us": 59.831999999601976, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "count": 24, + "cpu_time_us": 107.51200000003155, + "self_cpu_time_us": 33.10499999957392, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 74.40700000045763, + "self_cpu_time_us": 62.088000000527245, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::set_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456 + ], + [ + 456, + 1 + ] + ], + "count": 24, + "cpu_time_us": 97.92999999971653, + "self_cpu_time_us": 97.92999999971653, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 1 + ], + [], + [] + ], + "count": 24, + "cpu_time_us": 62.23899999939022, + "self_cpu_time_us": 52.43599999901198, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 6.775000000183354, + "self_cpu_time_us": 6.775000000183354, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [] + ], + "count": 24, + "cpu_time_us": 58.89400000081514, + "self_cpu_time_us": 42.589000000822125, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 200.8079999998008, + "self_cpu_time_us": 11.178999999523512, + "cuda_time_us": 10.110000000073342, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 79 + ], + [] + ], + "count": 8, + "cpu_time_us": 20.214999999807333, + "self_cpu_time_us": 20.214999999807333, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 79 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 41.61500000009255, + "self_cpu_time_us": 35.459999999788124, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 79 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 6.155000000304426, + "self_cpu_time_us": 6.155000000304426, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [] + ], + "count": 40, + "cpu_time_us": 116.9939999999333, + "self_cpu_time_us": 98.50999999945634, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [], + [] + ], + "count": 40, + "cpu_time_us": 18.484000000476954, + "self_cpu_time_us": 18.484000000476954, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 1 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 29.658000000112224, + "self_cpu_time_us": 23.146999999662512, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 1 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 6.511000000449712, + "self_cpu_time_us": 6.511000000449712, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 15 + ], + [] + ], + "count": 8, + "cpu_time_us": 7.132000000143307, + "self_cpu_time_us": 7.132000000143307, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 1 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 20.97499999984575, + "self_cpu_time_us": 16.706999999601976, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 15, + 1 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 4.268000000243774, + "self_cpu_time_us": 4.268000000243774, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 20 + ], + [] + ], + "count": 8, + "cpu_time_us": 5.459999999948195, + "self_cpu_time_us": 5.459999999948195, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 20 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 18.939999999885913, + "self_cpu_time_us": 14.832999999940512, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 20 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 4.106999999945401, + "self_cpu_time_us": 4.106999999945401, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 15, + 20 + ], + [] + ], + "count": 8, + "cpu_time_us": 7.842999999847962, + "self_cpu_time_us": 7.842999999847962, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 15, + 20 + ], + [] + ], + "count": 8, + "cpu_time_us": 21.952000000004773, + "self_cpu_time_us": 11.845000000103028, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 15, + 20 + ], + [] + ], + "count": 8, + "cpu_time_us": 10.106999999901745, + "self_cpu_time_us": 10.106999999901745, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 300 + ], + [], + [] + ], + "count": 16, + "cpu_time_us": 52.86899999997695, + "self_cpu_time_us": 44.4139999999461, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 300 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 8.45500000003085, + "self_cpu_time_us": 8.45500000003085, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 300 + ], + [ + 300 + ], + [] + ], + "count": 8, + "cpu_time_us": 10.172999999907915, + "self_cpu_time_us": 10.172999999907915, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::is_nonzero", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [] + ], + "count": 24, + "cpu_time_us": 403.09100000002945, + "self_cpu_time_us": 40.70800000037707, + "cuda_time_us": 22.653000000704196, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 77 + ], + [] + ], + "count": 8, + "cpu_time_us": 14.919000000139931, + "self_cpu_time_us": 14.919000000139931, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 77 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 33.4450000001234, + "self_cpu_time_us": 25.1780000001163, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 77 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 8.267000000007101, + "self_cpu_time_us": 8.267000000007101, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 456 + ], + [] + ], + "count": 8, + "cpu_time_us": 23.103000000090105, + "self_cpu_time_us": 12.996000000159256, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 456 + ], + [] + ], + "count": 8, + "cpu_time_us": 10.10699999993085, + "self_cpu_time_us": 10.10699999993085, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 456 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 4.387999999860767, + "self_cpu_time_us": 4.387999999860767, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 24.62599999990198, + "self_cpu_time_us": 20.059999999954016, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456 + ], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 8.97099999972852, + "self_cpu_time_us": 8.97099999972852, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::index_put_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 456 + ], + [], + [ + 3, + 456 + ], + [] + ], + "count": 8, + "cpu_time_us": 872.0899999999529, + "self_cpu_time_us": 99.79599999984202, + "cuda_time_us": 63.096000000296044, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 456 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 3.950000000098953, + "self_cpu_time_us": 3.950000000098953, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1 + ], + [] + ], + "count": 8, + "cpu_time_us": 39.02399999999034, + "self_cpu_time_us": 33.36700000007113, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cua.language", + "device_type": "DeviceType.CPU", + "is_user_annotation": true, + "input_shapes": [], + "count": 8, + "cpu_time_us": 1473940.775, + "self_cpu_time_us": 356723.7060000099, + "cuda_time_us": 502980.8289999702, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ], + [] + ], + "count": 8, + "cpu_time_us": 39.118000000322354, + "self_cpu_time_us": 32.281000000672066, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 6.836999999650288, + "self_cpu_time_us": 6.836999999650288, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32 + ], + [] + ], + "count": 8, + "cpu_time_us": 28.81600000000617, + "self_cpu_time_us": 24.122999999919557, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 4.693000000086613, + "self_cpu_time_us": 4.693000000086613, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 32 + ], + [] + ], + "count": 8, + "cpu_time_us": 265.1969999997964, + "self_cpu_time_us": 258.81399999976566, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 32 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 6.383000000030734, + "self_cpu_time_us": 6.383000000030734, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 32, + 1 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 3.4930000002495944, + "self_cpu_time_us": 3.4930000002495944, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 32, + 1 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 43.86099999987346, + "self_cpu_time_us": 35.966999999727705, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 1, + 32, + 1 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 7.894000000145752, + "self_cpu_time_us": 7.894000000145752, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456 + ], + [] + ], + "count": 8, + "cpu_time_us": 91.0980000001, + "self_cpu_time_us": 86.69300000031944, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 178.36200000003737, + "self_cpu_time_us": 13.107999999978347, + "cuda_time_us": 15.869000000238884, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 165.25400000005902, + "self_cpu_time_us": 32.871000000071945, + "cuda_time_us": 15.869000000238884, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 2.7629999998025596, + "self_cpu_time_us": 2.7629999998025596, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [ + 3, + 1, + 1, + 456 + ] + ], + "count": 8, + "cpu_time_us": 2037.9470000000874, + "self_cpu_time_us": 110.8279999999504, + "cuda_time_us": 11.519000000087544, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 32.23599999990256, + "self_cpu_time_us": 26.481999999828986, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 5.7540000000735745, + "self_cpu_time_us": 5.7540000000735745, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [] + ], + "count": 8, + "cpu_time_us": 60.439000000216765, + "self_cpu_time_us": 40.75500000039756, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 19.683999999819207, + "self_cpu_time_us": 19.683999999819207, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 23.456999999878462, + "self_cpu_time_us": 19.47099999996135, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 3.9859999999171123, + "self_cpu_time_us": 3.9859999999171123, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [] + ], + "count": 8, + "cpu_time_us": 28.29099999985192, + "self_cpu_time_us": 11.254999999597203, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [] + ], + "count": 8, + "cpu_time_us": 17.036000000254717, + "self_cpu_time_us": 17.036000000254717, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::bmm", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 32, + 1 + ], + [ + 3, + 1, + 456 + ] + ], + "count": 8, + "cpu_time_us": 1766.5040000000736, + "self_cpu_time_us": 292.36099999996077, + "cuda_time_us": 11.519000000087544, + "self_cuda_time_us": 0.0 + }, + { + "op": "cuLaunchKernelEx", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 8, + "cpu_time_us": 54.48800000004121, + "self_cpu_time_us": 54.48800000004121, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 32, + 456 + ], + [] + ], + "count": 8, + "cpu_time_us": 16.19200000021374, + "self_cpu_time_us": 16.19200000021374, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 456 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 44.27100000010978, + "self_cpu_time_us": 35.9340000001248, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 32, + 456 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 8.336999999984982, + "self_cpu_time_us": 8.336999999984982, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456, + 32 + ], + [], + [] + ], + "count": 48, + "cpu_time_us": 172.89799999997194, + "self_cpu_time_us": 143.1349999999511, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3, + 1, + 456, + 32 + ], + [], + [], + [] + ], + "count": 48, + "cpu_time_us": 29.76300000002084, + "self_cpu_time_us": 29.76300000002084, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [], + [], + [] + ], + "count": 64, + "cpu_time_us": 222.03500000019267, + "self_cpu_time_us": 185.7439999992348, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [], + [] + ], + "count": 448, + "cpu_time_us": 272.04400000213354, + "self_cpu_time_us": 272.04400000213354, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 64 + ], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 301.7880000002915, + "self_cpu_time_us": 23.867000000362168, + "cuda_time_us": 16.255999999310006, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 64 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 16, + "cpu_time_us": 277.92099999992934, + "self_cpu_time_us": 59.246000000610366, + "cuda_time_us": 16.255999999310006, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [], + [] + ], + "count": 2064, + "cpu_time_us": 29198.116000000926, + "self_cpu_time_us": 2863.8040000021138, + "cuda_time_us": 5856.111999996385, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 2064, + "cpu_time_us": 34744.20599999954, + "self_cpu_time_us": 7742.637999999002, + "cuda_time_us": 7070.087999992495, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::result_type", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 520, + "cpu_time_us": 186.7830000015092, + "self_cpu_time_us": 186.7830000015092, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560 + ], + [], + [], + [], + [] + ], + "count": 520, + "cpu_time_us": 9720.698000000775, + "self_cpu_time_us": 810.0230000011652, + "cuda_time_us": 1207.2710000000516, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 520, + "cpu_time_us": 8910.67499999961, + "self_cpu_time_us": 2074.731999999087, + "cuda_time_us": 1207.2710000000516, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::type_as", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 2560 + ] + ], + "count": 520, + "cpu_time_us": 10527.998000000793, + "self_cpu_time_us": 1245.0019999996293, + "cuda_time_us": 1213.9759999961097, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 520, + "cpu_time_us": 9282.996000001163, + "self_cpu_time_us": 873.1020000004355, + "cuda_time_us": 1213.9759999961097, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 8192, + 2560 + ], + [] + ], + "count": 256, + "cpu_time_us": 12219.208000001236, + "self_cpu_time_us": 687.932000003042, + "cuda_time_us": 37075.57599999878, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 2560 + ] + ], + "count": 256, + "cpu_time_us": 1197.235999999495, + "self_cpu_time_us": 487.29700000045705, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 2560 + ], + [], + [] + ], + "count": 256, + "cpu_time_us": 709.9389999990381, + "self_cpu_time_us": 525.514000000665, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 2560 + ], + [], + [], + [] + ], + "count": 256, + "cpu_time_us": 184.4249999983731, + "self_cpu_time_us": 184.4249999983731, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 8192 + ] + ], + "count": 256, + "cpu_time_us": 10334.039999998698, + "self_cpu_time_us": 1438.7009999988659, + "cuda_time_us": 37075.57599999878, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 2184, + "cpu_time_us": 5218.300000003335, + "self_cpu_time_us": 3135.3020000050747, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "count": 2184, + "cpu_time_us": 2082.9979999982606, + "self_cpu_time_us": 2082.9979999982606, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 8192 + ], + [] + ], + "count": 320, + "cpu_time_us": 250.61399999904097, + "self_cpu_time_us": 250.61399999904097, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 782.259999999791, + "self_cpu_time_us": 594.9489999994403, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [], + [], + [] + ], + "count": 768, + "cpu_time_us": 463.5630000016681, + "self_cpu_time_us": 463.5630000016681, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 4096, + 2560 + ], + [] + ], + "count": 192, + "cpu_time_us": 7765.9650000004185, + "self_cpu_time_us": 420.9620000007417, + "cuda_time_us": 15694.21899999943, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 2560 + ] + ], + "count": 192, + "cpu_time_us": 692.3770000002987, + "self_cpu_time_us": 293.9700000000739, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 2560 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 398.4070000002248, + "self_cpu_time_us": 305.6259999982867, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 4096, + 2560 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 92.78100000193808, + "self_cpu_time_us": 92.78100000193808, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 4096 + ] + ], + "count": 192, + "cpu_time_us": 6652.625999999378, + "self_cpu_time_us": 933.5299999999552, + "cuda_time_us": 15694.21899999943, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 4096 + ], + [] + ], + "count": 192, + "cpu_time_us": 122.15899999887915, + "self_cpu_time_us": 122.15899999887915, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [] + ], + "count": 704, + "cpu_time_us": 1916.8950000017358, + "self_cpu_time_us": 1104.3570000030013, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [] + ], + "count": 512, + "cpu_time_us": 655.0649999987654, + "self_cpu_time_us": 655.0649999987654, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 32, + 2560 + ], + [] + ], + "count": 384, + "cpu_time_us": 15272.63500000094, + "self_cpu_time_us": 756.2750000017695, + "cuda_time_us": 1981.3919999953505, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32, + 2560 + ] + ], + "count": 384, + "cpu_time_us": 1500.9459999998217, + "self_cpu_time_us": 731.487000001347, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32, + 2560 + ], + [], + [] + ], + "count": 384, + "cpu_time_us": 769.4589999984746, + "self_cpu_time_us": 589.0449999971461, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32, + 2560 + ], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 180.41400000132853, + "self_cpu_time_us": 180.41400000132853, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 32 + ] + ], + "count": 384, + "cpu_time_us": 13015.41399999935, + "self_cpu_time_us": 1728.6139999982843, + "cuda_time_us": 1981.3919999953505, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 32 + ], + [] + ], + "count": 384, + "cpu_time_us": 235.79299999956856, + "self_cpu_time_us": 235.79299999956856, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::zero_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 4 + ] + ], + "count": 192, + "cpu_time_us": 2847.075000000128, + "self_cpu_time_us": 621.1629999993602, + "cuda_time_us": 164.52700000061304, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 1971.621000000785, + "self_cpu_time_us": 1682.972000001173, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [], + [], + [] + ], + "count": 768, + "cpu_time_us": 562.8169999997917, + "self_cpu_time_us": 562.8169999997917, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::squeeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 1, + 4 + ], + [] + ], + "count": 192, + "cpu_time_us": 1118.5340000014403, + "self_cpu_time_us": 987.4080000023678, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 1, + 4 + ], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 237.3949999986944, + "self_cpu_time_us": 237.3949999986944, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 186.36199999939709, + "self_cpu_time_us": 186.36199999939709, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 4 + ], + [] + ], + "count": 192, + "cpu_time_us": 878.2459999996645, + "self_cpu_time_us": 751.0290000006935, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 4 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 127.216999998971, + "self_cpu_time_us": 127.216999998971, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::conv1d", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [ + 8192, + 1, + 4 + ], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 15890.996999997718, + "self_cpu_time_us": 761.7669999991631, + "cuda_time_us": 17611.019000000393, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::convolution", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [ + 8192, + 1, + 4 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 15129.229999998555, + "self_cpu_time_us": 1201.1799999985378, + "cuda_time_us": 17611.019000000393, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_convolution", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [ + 8192, + 1, + 4 + ], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 13928.050000000017, + "self_cpu_time_us": 3638.920000000144, + "cuda_time_us": 17611.019000000393, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::contiguous", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [] + ], + "count": 192, + "cpu_time_us": 4459.796999999933, + "self_cpu_time_us": 341.4550000006857, + "cuda_time_us": 8855.387999998784, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [] + ], + "count": 192, + "cpu_time_us": 4118.3419999992475, + "self_cpu_time_us": 734.0119999973685, + "cuda_time_us": 8855.387999998784, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 1396.7629999997444, + "self_cpu_time_us": 432.0989999992307, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [] + ], + "count": 192, + "cpu_time_us": 505.8360000005923, + "self_cpu_time_us": 369.5290000004461, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 1, + 4 + ], + [] + ], + "count": 192, + "cpu_time_us": 447.36599999916507, + "self_cpu_time_us": 341.0969999995432, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::squeeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 1, + 459 + ], + [] + ], + "count": 192, + "cpu_time_us": 525.2909999990807, + "self_cpu_time_us": 426.0860000002431, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 1, + 459 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 99.2049999988376, + "self_cpu_time_us": 99.2049999988376, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 459 + ], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 799.2639999995008, + "self_cpu_time_us": 640.559000000183, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 459 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 158.7049999993178, + "self_cpu_time_us": 158.7049999993178, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 847.93799999982, + "self_cpu_time_us": 710.0769999997865, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::split_with_sizes", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 1818.5989999983285, + "self_cpu_time_us": 1542.3469999970112, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2048 + ], + [] + ], + "count": 384, + "cpu_time_us": 2053.373000000196, + "self_cpu_time_us": 1435.9330000009213, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2048 + ], + [], + [] + ], + "count": 384, + "cpu_time_us": 617.4399999992747, + "self_cpu_time_us": 617.4399999992747, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 157.47299999996903, + "self_cpu_time_us": 157.47299999996903, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 4123.880999999048, + "self_cpu_time_us": 301.3619999993098, + "cuda_time_us": 286.5650000012538, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 3822.5189999997383, + "self_cpu_time_us": 890.9080000004178, + "cuda_time_us": 286.5650000012538, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 3529.9730000027776, + "self_cpu_time_us": 247.26900000263413, + "cuda_time_us": 381.164999999688, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 3282.7040000001434, + "self_cpu_time_us": 708.441999997216, + "cuda_time_us": 381.164999999688, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::repeat_interleave", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 128 + ], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 14121.61299999729, + "self_cpu_time_us": 2423.743999996368, + "cuda_time_us": 8780.33300000077, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 128 + ], + [] + ], + "count": 384, + "cpu_time_us": 1365.9859999993641, + "self_cpu_time_us": 1035.242000000624, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 128 + ], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 330.74399999874004, + "self_cpu_time_us": 330.74399999874004, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 1, + 128 + ], + [], + [] + ], + "count": 384, + "cpu_time_us": 1641.6610000013898, + "self_cpu_time_us": 1376.9949999998644, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 1, + 128 + ], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 264.6660000015254, + "self_cpu_time_us": 264.6660000015254, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 2, + 128 + ], + [] + ], + "count": 384, + "cpu_time_us": 7340.041000001365, + "self_cpu_time_us": 1277.7720000075205, + "cuda_time_us": 8780.33300000077, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 2, + 128 + ], + [], + [], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 2309.376999996719, + "self_cpu_time_us": 603.0899999988178, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::flatten", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 2, + 128 + ], + [], + [] + ], + "count": 384, + "cpu_time_us": 1350.1809999988036, + "self_cpu_time_us": 775.1780000001017, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 2, + 128 + ], + [] + ], + "count": 384, + "cpu_time_us": 575.0029999987019, + "self_cpu_time_us": 575.0029999987019, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [], + [] + ], + "count": 576, + "cpu_time_us": 1953.9930000014137, + "self_cpu_time_us": 1522.7670000027283, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [], + [], + [] + ], + "count": 576, + "cpu_time_us": 431.22599999868544, + "self_cpu_time_us": 431.22599999868544, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [], + [], + [] + ], + "count": 576, + "cpu_time_us": 11050.280999999915, + "self_cpu_time_us": 1091.305999999211, + "cuda_time_us": 4524.539000000266, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 576, + "cpu_time_us": 9958.975000000704, + "self_cpu_time_us": 1910.1099999987782, + "cuda_time_us": 4524.539000000266, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [] + ], + "count": 384, + "cpu_time_us": 1188.7869999969553, + "self_cpu_time_us": 953.0339999957796, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456 + ], + [], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 3407.4469999986904, + "self_cpu_time_us": 320.64699999813456, + "cuda_time_us": 430.7340000005497, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 3086.800000000556, + "self_cpu_time_us": 583.4110000002547, + "cuda_time_us": 430.7340000005497, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::pad", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [], + [] + ], + "count": 576, + "cpu_time_us": 19901.374000000185, + "self_cpu_time_us": 1094.4890000006417, + "cuda_time_us": 5324.129999997953, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::constant_pad_nd", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [] + ], + "count": 576, + "cpu_time_us": 18806.884999999544, + "self_cpu_time_us": 3846.4309999891702, + "cuda_time_us": 5324.129999997953, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [], + [], + [] + ], + "count": 576, + "cpu_time_us": 2652.8120000045164, + "self_cpu_time_us": 1128.9110000078945, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [], + [], + [], + [] + ], + "count": 768, + "cpu_time_us": 2512.484999994849, + "self_cpu_time_us": 1994.1549999920098, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [], + [], + [] + ], + "count": 768, + "cpu_time_us": 518.3300000028394, + "self_cpu_time_us": 518.3300000028394, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::pad", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456 + ], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 11399.672000000399, + "self_cpu_time_us": 551.7840000014112, + "cuda_time_us": 862.2479999978968, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::constant_pad_nd", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456 + ], + [], + [] + ], + "count": 384, + "cpu_time_us": 10847.887999998988, + "self_cpu_time_us": 1991.3889999992825, + "cuda_time_us": 862.2479999978968, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 1435.5339999973512, + "self_cpu_time_us": 536.3959999979852, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 899.137999999366, + "self_cpu_time_us": 693.0210000023508, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [], + [], + [] + ], + "count": 768, + "cpu_time_us": 449.2499999963038, + "self_cpu_time_us": 449.2499999963038, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [] + ], + "count": 384, + "cpu_time_us": 1472.564999999653, + "self_cpu_time_us": 1229.4320000003645, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [] + ], + "count": 768, + "cpu_time_us": 2133.407999998788, + "self_cpu_time_us": 1108.166999996698, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [] + ], + "count": 768, + "cpu_time_us": 1025.24100000209, + "self_cpu_time_us": 1025.24100000209, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [] + ], + "count": 192, + "cpu_time_us": 497.93300000020827, + "self_cpu_time_us": 252.22600000009697, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [] + ], + "count": 192, + "cpu_time_us": 245.7070000001113, + "self_cpu_time_us": 245.7070000001113, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::ones", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 3661.7539999991423, + "self_cpu_time_us": 905.7279999993334, + "cuda_time_us": 169.52099999965867, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 81.4390000000567, + "self_cpu_time_us": 81.4390000000567, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [] + ], + "count": 960, + "cpu_time_us": 3314.260000001508, + "self_cpu_time_us": 2636.692000002062, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [], + [], + [] + ], + "count": 1344, + "cpu_time_us": 997.9539999994886, + "self_cpu_time_us": 997.9539999994886, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::masked_fill", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [ + 64, + 64 + ], + [] + ], + "count": 192, + "cpu_time_us": 11996.572000000568, + "self_cpu_time_us": 1633.9390000026178, + "cuda_time_us": 1355.5820000035164, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 588.020999999906, + "self_cpu_time_us": 456.76900000017486, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [], + [], + [] + ], + "count": 2112, + "cpu_time_us": 1207.6130000003031, + "self_cpu_time_us": 1207.6130000003031, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 64, + 64 + ], + [], + [] + ], + "count": 384, + "cpu_time_us": 1039.6289999970904, + "self_cpu_time_us": 770.570999996402, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 64, + 64 + ], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 269.0580000006885, + "self_cpu_time_us": 269.0580000006885, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [] + ], + "count": 192, + "cpu_time_us": 5712.336999999228, + "self_cpu_time_us": 618.204999999376, + "cuda_time_us": 602.3740000008547, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 1102.286999999691, + "self_cpu_time_us": 277.2929999996122, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [] + ], + "count": 1152, + "cpu_time_us": 3228.2659999994066, + "self_cpu_time_us": 2580.726000000126, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [], + [] + ], + "count": 9216, + "cpu_time_us": 5135.18199998817, + "self_cpu_time_us": 5135.18199998817, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [ + 1, + 32, + 8, + 128, + 64 + ] + ], + "count": 384, + "cpu_time_us": 28583.218999997654, + "self_cpu_time_us": 4331.723999998721, + "cuda_time_us": 9372.42799999869, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [] + ], + "count": 384, + "cpu_time_us": 1254.5020000003133, + "self_cpu_time_us": 1023.9130000014266, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "count": 576, + "cpu_time_us": 6166.157000003528, + "self_cpu_time_us": 1480.773000005429, + "cuda_time_us": 4018.834999999526, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "count": 384, + "cpu_time_us": 486.92100000013306, + "self_cpu_time_us": 486.92100000013306, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [], + [] + ], + "count": 384, + "cpu_time_us": 1055.998999999807, + "self_cpu_time_us": 821.6800000004878, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 234.3189999993192, + "self_cpu_time_us": 234.3189999993192, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [] + ], + "count": 384, + "cpu_time_us": 1610.489999999394, + "self_cpu_time_us": 1094.4439999997267, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [], + [] + ], + "count": 384, + "cpu_time_us": 516.0459999996674, + "self_cpu_time_us": 516.0459999996674, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 256, + 64, + 64 + ], + [] + ], + "count": 384, + "cpu_time_us": 437.3039999972534, + "self_cpu_time_us": 437.3039999972534, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [], + [] + ], + "count": 384, + "cpu_time_us": 893.0629999983794, + "self_cpu_time_us": 648.4670000014448, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [], + [] + ], + "count": 384, + "cpu_time_us": 1667.316999995237, + "self_cpu_time_us": 856.1569999942294, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 811.1600000010076, + "self_cpu_time_us": 811.1600000010076, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::arange", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [], + [], + [], + [], + [], + [], + [] + ], + "count": 768, + "cpu_time_us": 14459.116999999693, + "self_cpu_time_us": 2422.5440000046656, + "cuda_time_us": 658.0419999988662, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::zero_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ] + ], + "count": 384, + "cpu_time_us": 4602.771000001099, + "self_cpu_time_us": 1137.326000001689, + "cuda_time_us": 597.5909999975993, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::zeros_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 3990.0229999987932, + "self_cpu_time_us": 515.1649999990477, + "cuda_time_us": 809.920000000202, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [], + [], + [], + [] + ], + "count": 384, + "cpu_time_us": 2817.2519999984943, + "self_cpu_time_us": 831.4360000012966, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::zero_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ] + ], + "count": 192, + "cpu_time_us": 1959.007999999274, + "self_cpu_time_us": 493.74399999983143, + "cuda_time_us": 809.920000000202, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 1192.0530000006402, + "self_cpu_time_us": 998.714000000633, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 1065.8639999994484, + "self_cpu_time_us": 938.8169999994134, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8 + ], + [] + ], + "count": 192, + "cpu_time_us": 550.8269999997283, + "self_cpu_time_us": 448.3959999993531, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 102.4310000003752, + "self_cpu_time_us": 102.4310000003752, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 1 + ], + [] + ], + "count": 192, + "cpu_time_us": 571.3679999994929, + "self_cpu_time_us": 444.56999999971595, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 1 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 126.79799999977695, + "self_cpu_time_us": 126.79799999977695, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [] + ], + "count": 7680, + "cpu_time_us": 23785.740999988702, + "self_cpu_time_us": 19529.82299999871, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [ + 1, + 32, + 128, + 128 + ] + ], + "count": 3072, + "cpu_time_us": 136354.09700000274, + "self_cpu_time_us": 29716.21600000975, + "cuda_time_us": 38231.32100000439, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [], + [] + ], + "count": 6144, + "cpu_time_us": 17335.191999996125, + "self_cpu_time_us": 14043.352999996496, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [], + [], + [] + ], + "count": 7680, + "cpu_time_us": 4237.671999999846, + "self_cpu_time_us": 4237.671999999846, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [] + ], + "count": 6144, + "cpu_time_us": 16212.317000002673, + "self_cpu_time_us": 11269.218999994715, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [], + [] + ], + "count": 6144, + "cpu_time_us": 4943.098000007958, + "self_cpu_time_us": 4943.098000007958, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [], + [] + ], + "count": 3072, + "cpu_time_us": 7552.344000001351, + "self_cpu_time_us": 6372.246999997413, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [], + [], + [] + ], + "count": 3072, + "cpu_time_us": 1180.0970000039379, + "self_cpu_time_us": 1180.0970000039379, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [] + ], + "count": 3072, + "cpu_time_us": 6240.667999992424, + "self_cpu_time_us": 3463.010999985854, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [] + ], + "count": 3072, + "cpu_time_us": 2777.6570000065694, + "self_cpu_time_us": 2777.6570000065694, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32, + 64, + 128 + ], + [] + ], + "count": 4608, + "cpu_time_us": 3032.8779999998224, + "self_cpu_time_us": 3032.8779999998224, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [], + [] + ], + "count": 1536, + "cpu_time_us": 4551.7489999978425, + "self_cpu_time_us": 3719.983999994205, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 64 + ], + [ + 1, + 32, + 64, + 128 + ] + ], + "count": 1536, + "cpu_time_us": 64445.29100000154, + "self_cpu_time_us": 13839.449999995762, + "cuda_time_us": 12909.12599999897, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 64 + ], + [], + [] + ], + "count": 1536, + "cpu_time_us": 4396.648999998768, + "self_cpu_time_us": 3453.784000001062, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 64 + ], + [], + [], + [] + ], + "count": 1536, + "cpu_time_us": 942.864999997706, + "self_cpu_time_us": 942.864999997706, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 64 + ], + [] + ], + "count": 1536, + "cpu_time_us": 4159.535000005839, + "self_cpu_time_us": 2900.626000004617, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 64 + ], + [], + [] + ], + "count": 1536, + "cpu_time_us": 1258.909000001222, + "self_cpu_time_us": 1258.909000001222, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 1, + 1 + ], + [], + [] + ], + "count": 1536, + "cpu_time_us": 4682.152000001879, + "self_cpu_time_us": 3808.7720000018744, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 1, + 1 + ], + [], + [], + [] + ], + "count": 1536, + "cpu_time_us": 873.3800000000047, + "self_cpu_time_us": 873.3800000000047, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [], + [] + ], + "count": 1536, + "cpu_time_us": 4925.99599999981, + "self_cpu_time_us": 3980.162999999593, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 64 + ], + [ + 1, + 32, + 64, + 128 + ] + ], + "count": 1536, + "cpu_time_us": 67923.00099999864, + "self_cpu_time_us": 13734.16399998861, + "cuda_time_us": 12406.341999998258, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 64 + ], + [], + [] + ], + "count": 1536, + "cpu_time_us": 4835.613000002806, + "self_cpu_time_us": 3917.6680000058404, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 64 + ], + [], + [], + [] + ], + "count": 1536, + "cpu_time_us": 917.9449999969656, + "self_cpu_time_us": 917.9449999969656, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 64 + ], + [] + ], + "count": 1536, + "cpu_time_us": 4633.364000000802, + "self_cpu_time_us": 3339.2380000048433, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 64 + ], + [], + [] + ], + "count": 1536, + "cpu_time_us": 1294.1259999959584, + "self_cpu_time_us": 1294.1259999959584, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 32, + 128, + 128 + ], + [] + ], + "count": 1536, + "cpu_time_us": 1026.7780000032508, + "self_cpu_time_us": 1026.7780000032508, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "count": 192, + "cpu_time_us": 4059.730999998763, + "self_cpu_time_us": 883.9360000008455, + "cuda_time_us": 4018.834999999526, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "count": 192, + "cpu_time_us": 138.73199999920325, + "self_cpu_time_us": 138.73199999920325, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [] + ], + "count": 192, + "cpu_time_us": 610.0289999990637, + "self_cpu_time_us": 476.50599999826227, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 133.5230000008014, + "self_cpu_time_us": 133.5230000008014, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 4247.07900000058, + "self_cpu_time_us": 500.79799999902025, + "cuda_time_us": 906.689000000697, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 3746.2810000015597, + "self_cpu_time_us": 835.5900000001275, + "cuda_time_us": 906.689000000697, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::zeros_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 4395.329000000755, + "self_cpu_time_us": 670.4260000003997, + "cuda_time_us": 300.21999999879336, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 1379.3579999994981, + "self_cpu_time_us": 455.06100000071456, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [] + ], + "count": 384, + "cpu_time_us": 1349.262999998682, + "self_cpu_time_us": 748.7889999978361, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [] + ], + "count": 384, + "cpu_time_us": 600.474000000846, + "self_cpu_time_us": 600.474000000846, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [], + [], + [], + [] + ], + "count": 960, + "cpu_time_us": 14947.343999997538, + "self_cpu_time_us": 1321.8109999992303, + "cuda_time_us": 3940.564999998125, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 768, + "cpu_time_us": 13625.532999998308, + "self_cpu_time_us": 3131.377999996752, + "cuda_time_us": 3940.564999998125, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::result_type", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [] + ], + "count": 192, + "cpu_time_us": 137.17200000023877, + "self_cpu_time_us": 137.17200000023877, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [] + ], + "count": 192, + "cpu_time_us": 660.182999999568, + "self_cpu_time_us": 323.14600000026985, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 14592, + 128 + ], + [] + ], + "count": 192, + "cpu_time_us": 337.03699999929813, + "self_cpu_time_us": 337.03699999929813, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 2560, + 4096 + ], + [] + ], + "count": 256, + "cpu_time_us": 15868.111000000456, + "self_cpu_time_us": 1031.5870000027498, + "cuda_time_us": 22939.256000000212, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 4096, + 2560 + ] + ], + "count": 256, + "cpu_time_us": 13334.232999999469, + "self_cpu_time_us": 1791.3830000002345, + "cuda_time_us": 22939.256000000212, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 2560 + ], + [] + ], + "count": 832, + "cpu_time_us": 651.3410000046715, + "self_cpu_time_us": 651.3410000046715, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 9216, + 2560 + ], + [] + ], + "count": 512, + "cpu_time_us": 21119.30300000032, + "self_cpu_time_us": 1221.11199999995, + "cuda_time_us": 91341.24299999687, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 9216, + 2560 + ] + ], + "count": 512, + "cpu_time_us": 2517.4839999971446, + "self_cpu_time_us": 1065.9419999996608, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 9216, + 2560 + ], + [], + [] + ], + "count": 512, + "cpu_time_us": 1451.5419999974838, + "self_cpu_time_us": 1108.4409999996278, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 9216, + 2560 + ], + [], + [], + [] + ], + "count": 512, + "cpu_time_us": 343.100999997856, + "self_cpu_time_us": 343.100999997856, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 9216 + ] + ], + "count": 512, + "cpu_time_us": 17380.707000003225, + "self_cpu_time_us": 2706.433000002129, + "cuda_time_us": 91341.24299999687, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 9216 + ], + [] + ], + "count": 1024, + "cpu_time_us": 736.5570000032312, + "self_cpu_time_us": 736.5570000032312, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [] + ], + "count": 704, + "cpu_time_us": 217.74400000086462, + "self_cpu_time_us": 217.74400000086462, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 16, + 2560 + ], + [] + ], + "count": 704, + "cpu_time_us": 27218.147000002733, + "self_cpu_time_us": 1691.5240000082413, + "cuda_time_us": 5687.058999997476, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 2560 + ] + ], + "count": 704, + "cpu_time_us": 2769.4149999961955, + "self_cpu_time_us": 1175.3069999956933, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 2560 + ], + [], + [] + ], + "count": 704, + "cpu_time_us": 1594.1080000005022, + "self_cpu_time_us": 1193.6960000001127, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 2560 + ], + [], + [], + [] + ], + "count": 704, + "cpu_time_us": 400.4120000003895, + "self_cpu_time_us": 400.4120000003895, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 16 + ] + ], + "count": 704, + "cpu_time_us": 22757.207999998296, + "self_cpu_time_us": 3402.149999992718, + "cuda_time_us": 5687.058999997476, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 16 + ], + [] + ], + "count": 1024, + "cpu_time_us": 722.1340000013006, + "self_cpu_time_us": 722.1340000013006, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 9216, + 16 + ], + [] + ], + "count": 512, + "cpu_time_us": 15003.547000000399, + "self_cpu_time_us": 1186.871000002022, + "cuda_time_us": 6404.582999999548, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 9216, + 16 + ] + ], + "count": 512, + "cpu_time_us": 1830.857999997388, + "self_cpu_time_us": 738.1749999968015, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 9216, + 16 + ], + [], + [] + ], + "count": 512, + "cpu_time_us": 1092.6830000005866, + "self_cpu_time_us": 838.6020000000863, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 9216, + 16 + ], + [], + [], + [] + ], + "count": 512, + "cpu_time_us": 254.08100000050035, + "self_cpu_time_us": 254.08100000050035, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 16, + 9216 + ] + ], + "count": 512, + "cpu_time_us": 11985.818000000989, + "self_cpu_time_us": 2397.719000001671, + "cuda_time_us": 6404.582999999548, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [] + ], + "count": 1024, + "cpu_time_us": 2092.050999997693, + "self_cpu_time_us": 1270.9400000000023, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [] + ], + "count": 1024, + "cpu_time_us": 821.1109999976907, + "self_cpu_time_us": 821.1109999976907, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [], + [], + [], + [] + ], + "count": 768, + "cpu_time_us": 14111.353000002127, + "self_cpu_time_us": 1075.707000002425, + "cuda_time_us": 6107.255999999368, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 768, + "cpu_time_us": 13035.645999999702, + "self_cpu_time_us": 3053.8479999973497, + "cuda_time_us": 6107.255999999368, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 2560, + 9216 + ], + [] + ], + "count": 256, + "cpu_time_us": 9288.749999999738, + "self_cpu_time_us": 612.2960000007442, + "cuda_time_us": 45215.69199999863, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 9216 + ] + ], + "count": 256, + "cpu_time_us": 969.0859999979439, + "self_cpu_time_us": 418.2709999973449, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 9216 + ], + [], + [] + ], + "count": 256, + "cpu_time_us": 550.815000000599, + "self_cpu_time_us": 420.38899999945716, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 2560, + 9216 + ], + [], + [], + [] + ], + "count": 256, + "cpu_time_us": 130.4260000011418, + "self_cpu_time_us": 130.4260000011418, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 9216, + 2560 + ] + ], + "count": 256, + "cpu_time_us": 7707.36800000105, + "self_cpu_time_us": 1210.3979999996518, + "cuda_time_us": 45215.69199999863, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [] + ], + "count": 512, + "cpu_time_us": 1062.8060000001278, + "self_cpu_time_us": 608.6580000007671, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [] + ], + "count": 512, + "cpu_time_us": 454.14799999936076, + "self_cpu_time_us": 454.14799999936076, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [], + [] + ], + "count": 256, + "cpu_time_us": 47.17999999970198, + "self_cpu_time_us": 47.17999999970198, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 16, + 9216 + ], + [] + ], + "count": 256, + "cpu_time_us": 8997.137000001225, + "self_cpu_time_us": 645.1080000003567, + "cuda_time_us": 3680.546999999351, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 9216 + ] + ], + "count": 256, + "cpu_time_us": 974.8530000004394, + "self_cpu_time_us": 383.47100000114006, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 9216 + ], + [], + [] + ], + "count": 256, + "cpu_time_us": 591.3819999992993, + "self_cpu_time_us": 442.4469999979483, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 16, + 9216 + ], + [], + [], + [] + ], + "count": 256, + "cpu_time_us": 148.935000001351, + "self_cpu_time_us": 148.935000001351, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 9216, + 16 + ] + ], + "count": 256, + "cpu_time_us": 7377.176000000429, + "self_cpu_time_us": 1175.180000000386, + "cuda_time_us": 3680.546999999351, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 2560, + 16 + ], + [] + ], + "count": 320, + "cpu_time_us": 9076.198999999644, + "self_cpu_time_us": 617.0940000017144, + "cuda_time_us": 1476.288999998389, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 16, + 2560 + ] + ], + "count": 320, + "cpu_time_us": 7278.079000000202, + "self_cpu_time_us": 1567.8939999956492, + "cuda_time_us": 1476.288999998389, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 8192, + 16 + ], + [] + ], + "count": 64, + "cpu_time_us": 2465.152999999511, + "self_cpu_time_us": 130.70199999892793, + "cuda_time_us": 786.0240000011836, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 16 + ] + ], + "count": 64, + "cpu_time_us": 288.3980000007723, + "self_cpu_time_us": 162.81800000093062, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 16 + ], + [], + [] + ], + "count": 64, + "cpu_time_us": 125.57999999984168, + "self_cpu_time_us": 96.66600000021572, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 8192, + 16 + ], + [], + [], + [] + ], + "count": 64, + "cpu_time_us": 28.913999999625958, + "self_cpu_time_us": 28.913999999625958, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 16, + 8192 + ] + ], + "count": 64, + "cpu_time_us": 2046.0529999998107, + "self_cpu_time_us": 261.5249999990483, + "cuda_time_us": 786.0240000011836, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [], + [], + [], + [] + ], + "count": 64, + "cpu_time_us": 1146.8370000012656, + "self_cpu_time_us": 88.05500000101165, + "cuda_time_us": 366.2319999998872, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 64, + "cpu_time_us": 1058.782000000254, + "self_cpu_time_us": 238.57000000070548, + "cuda_time_us": 366.2319999998872, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [] + ], + "count": 64, + "cpu_time_us": 114.60100000021339, + "self_cpu_time_us": 114.60100000021339, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::chunk", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 512 + ], + [], + [] + ], + "count": 64, + "cpu_time_us": 1493.8600000004662, + "self_cpu_time_us": 209.9330000000482, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::split", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 512 + ], + [], + [] + ], + "count": 64, + "cpu_time_us": 1283.927000000418, + "self_cpu_time_us": 357.2299999995885, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 512 + ], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 926.6970000008296, + "self_cpu_time_us": 391.88900000260037, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 512 + ], + [], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 534.8079999982292, + "self_cpu_time_us": 426.8899999982241, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 512 + ], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 107.91800000000512, + "self_cpu_time_us": 107.91800000000512, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 128, + "cpu_time_us": 2217.15599999993, + "self_cpu_time_us": 532.0590000017837, + "cuda_time_us": 279.06599999986065, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 128, + "cpu_time_us": 2897.8380000006437, + "self_cpu_time_us": 545.4679999986402, + "cuda_time_us": 576.5389999999752, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [], + [], + [] + ], + "count": 192, + "cpu_time_us": 1242.4540000016714, + "self_cpu_time_us": 411.0670000013779, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 64, + "cpu_time_us": 48.963999999148655, + "self_cpu_time_us": 48.963999999148655, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 128, + "cpu_time_us": 233.59400000002643, + "self_cpu_time_us": 233.59400000002643, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 1325.206999999078, + "self_cpu_time_us": 105.29499999884865, + "cuda_time_us": 410.67800000082934, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 2234.7170000003243, + "self_cpu_time_us": 490.7829999993555, + "cuda_time_us": 635.1620000004623, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::result_type", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 64, + "cpu_time_us": 20.548999999955413, + "self_cpu_time_us": 20.548999999955413, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 256 + ], + [], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 2308.468999998382, + "self_cpu_time_us": 166.9539999987901, + "cuda_time_us": 232.89900000031048, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 256 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 2141.514999999592, + "self_cpu_time_us": 493.3879999996425, + "cuda_time_us": 232.89900000031048, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::type_as", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [ + 1, + 456, + 16, + 256 + ] + ], + "count": 64, + "cpu_time_us": 1226.5660000008065, + "self_cpu_time_us": 119.28300000037416, + "cuda_time_us": 224.48399999963294, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 64, + "cpu_time_us": 1107.2830000004324, + "self_cpu_time_us": 92.47800000033749, + "cuda_time_us": 224.48399999963294, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [] + ], + "count": 128, + "cpu_time_us": 444.2179999998625, + "self_cpu_time_us": 356.7750000006781, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 87.4429999991844, + "self_cpu_time_us": 87.4429999991844, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1024, + 2560 + ], + [] + ], + "count": 128, + "cpu_time_us": 4492.729000000763, + "self_cpu_time_us": 294.1360000011191, + "cuda_time_us": 2686.95000000071, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 2560 + ] + ], + "count": 128, + "cpu_time_us": 522.450999999608, + "self_cpu_time_us": 228.51899999991292, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 2560 + ], + [], + [] + ], + "count": 128, + "cpu_time_us": 293.9319999996951, + "self_cpu_time_us": 233.2590000006603, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1024, + 2560 + ], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 60.6729999990348, + "self_cpu_time_us": 60.6729999990348, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 1024 + ] + ], + "count": 128, + "cpu_time_us": 3676.142000000036, + "self_cpu_time_us": 606.9250000010652, + "cuda_time_us": 2686.95000000071, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 1024 + ], + [] + ], + "count": 256, + "cpu_time_us": 184.36599999993632, + "self_cpu_time_us": 184.36599999993632, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 1024, + 16 + ], + [] + ], + "count": 128, + "cpu_time_us": 4567.972000000824, + "self_cpu_time_us": 262.054000002885, + "cuda_time_us": 4055.833000000028, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 16, + 1024 + ] + ], + "count": 128, + "cpu_time_us": 3847.5089999983757, + "self_cpu_time_us": 598.681999999535, + "cuda_time_us": 4055.833000000028, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 2327.7539999998116, + "self_cpu_time_us": 211.98499999952037, + "cuda_time_us": 196.38300000001618, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 2115.7690000002913, + "self_cpu_time_us": 515.5010000005132, + "cuda_time_us": 196.38300000001618, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [] + ], + "count": 128, + "cpu_time_us": 199.6880000000092, + "self_cpu_time_us": 199.6880000000092, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 1197.446000001044, + "self_cpu_time_us": 162.82200000068406, + "cuda_time_us": 155.08800000043993, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 2057.4180000003835, + "self_cpu_time_us": 433.50000000037835, + "cuda_time_us": 250.62700000031327, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::result_type", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [] + ], + "count": 64, + "cpu_time_us": 18.037999999854947, + "self_cpu_time_us": 18.037999999854947, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::type_as", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [ + 1, + 456, + 4, + 256 + ] + ], + "count": 64, + "cpu_time_us": 1289.1390000005777, + "self_cpu_time_us": 173.7550000007177, + "cuda_time_us": 95.53899999987334, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 64, + "cpu_time_us": 1115.38399999986, + "self_cpu_time_us": 92.58999999983644, + "cuda_time_us": 95.53899999987334, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [] + ], + "count": 128, + "cpu_time_us": 494.66900000073656, + "self_cpu_time_us": 390.37600000057137, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 104.2930000001652, + "self_cpu_time_us": 104.2930000001652, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 64 + ], + [] + ], + "count": 128, + "cpu_time_us": 454.2459999991406, + "self_cpu_time_us": 378.4859999989276, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 64 + ], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 75.76000000021304, + "self_cpu_time_us": 75.76000000021304, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 256 + ], + [], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 553.0130000003119, + "self_cpu_time_us": 476.8519999998098, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 256 + ], + [], + [], + [] + ], + "count": 256, + "cpu_time_us": 159.36100000105216, + "self_cpu_time_us": 159.36100000105216, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 256 + ], + [], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 400.73200000004726, + "self_cpu_time_us": 336.2930000001361, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 256 + ], + [], + [], + [] + ], + "count": 256, + "cpu_time_us": 130.84799999960524, + "self_cpu_time_us": 130.84799999960524, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 64 + ], + [], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 372.30599999985134, + "self_cpu_time_us": 302.9899999989866, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 64 + ], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 69.31600000086473, + "self_cpu_time_us": 69.31600000086473, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 64 + ], + [], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 428.48400000084075, + "self_cpu_time_us": 358.47400000152993, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 64 + ], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 70.00999999931082, + "self_cpu_time_us": 70.00999999931082, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ], + [], + [], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 1275.8019999995304, + "self_cpu_time_us": 252.04999999859137, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 128, + "cpu_time_us": 1023.752000000939, + "self_cpu_time_us": 476.1550000025891, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::lift_fresh", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ] + ], + "count": 128, + "cpu_time_us": 28.634000000049127, + "self_cpu_time_us": 28.634000000049127, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ] + ], + "count": 128, + "cpu_time_us": 273.87599999897066, + "self_cpu_time_us": 170.83600000018487, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 0 + ] + ], + "count": 128, + "cpu_time_us": 103.03999999878579, + "self_cpu_time_us": 103.03999999878579, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::scaled_dot_product_attention", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 256 + ], + [ + 1, + 4, + 456, + 256 + ], + [ + 1, + 4, + 456, + 256 + ], + [], + [], + [], + [], + [] + ], + "count": 64, + "cpu_time_us": 6627.072000000291, + "self_cpu_time_us": 934.9360000000161, + "cuda_time_us": 2629.801000001331, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_scaled_dot_product_flash_attention", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 256 + ], + [ + 1, + 4, + 456, + 256 + ], + [ + 1, + 4, + 456, + 256 + ], + [], + [], + [], + [] + ], + "count": 64, + "cpu_time_us": 5692.136000000275, + "self_cpu_time_us": 654.8970000017871, + "cuda_time_us": 2629.801000001331, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 16, + 456, + 256 + ], + [], + [] + ], + "count": 128, + "cpu_time_us": 413.30100000000675, + "self_cpu_time_us": 330.1009999994567, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 4, + 456, + 256 + ], + [], + [] + ], + "count": 128, + "cpu_time_us": 262.8070000003063, + "self_cpu_time_us": 196.39800000061223, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::contiguous", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "count": 64, + "cpu_time_us": 1520.7669999999343, + "self_cpu_time_us": 124.39799999920069, + "cuda_time_us": 297.47300000011455, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [], + [], + [], + [] + ], + "count": 64, + "cpu_time_us": 1323.7829999992973, + "self_cpu_time_us": 101.5049999988405, + "cuda_time_us": 392.36999999926775, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 64, + "cpu_time_us": 1222.2780000004568, + "self_cpu_time_us": 248.53100000042468, + "cuda_time_us": 392.36999999926775, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [], + [] + ], + "count": 64, + "cpu_time_us": 21.007999999972526, + "self_cpu_time_us": 21.007999999972526, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 16, + 4096 + ], + [] + ], + "count": 64, + "cpu_time_us": 2731.784999999858, + "self_cpu_time_us": 136.4630000012403, + "cuda_time_us": 630.8419999991602, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 4096, + 16 + ] + ], + "count": 64, + "cpu_time_us": 2274.308999998524, + "self_cpu_time_us": 384.24999999976717, + "cuda_time_us": 630.8419999991602, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::alias", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ] + ], + "count": 8, + "cpu_time_us": 38.088000000221655, + "self_cpu_time_us": 38.088000000221655, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cua.output_projection", + "device_type": "DeviceType.CPU", + "is_user_annotation": true, + "input_shapes": [], + "count": 8, + "cpu_time_us": 714.548999999708, + "self_cpu_time_us": 253.5019999994547, + "cuda_time_us": 35722.330000000075, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 248320, + 2560 + ], + [] + ], + "count": 8, + "cpu_time_us": 461.0470000002533, + "self_cpu_time_us": 21.818000000261236, + "cuda_time_us": 35722.330000000075, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320, + 2560 + ] + ], + "count": 8, + "cpu_time_us": 47.71699999977136, + "self_cpu_time_us": 18.33299999992596, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320, + 2560 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 29.3839999998454, + "self_cpu_time_us": 20.847999999881722, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 248320 + ] + ], + "count": 8, + "cpu_time_us": 391.5120000002207, + "self_cpu_time_us": 58.2949999999837, + "cuda_time_us": 35722.330000000075, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 248320 + ], + [] + ], + "count": 8, + "cpu_time_us": 9.25399999995716, + "self_cpu_time_us": 9.25399999995716, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cua.readout", + "device_type": "DeviceType.CPU", + "is_user_annotation": true, + "input_shapes": [], + "count": 8, + "cpu_time_us": 37563.17000000022, + "self_cpu_time_us": 1857.0379999998258, + "cuda_time_us": 50.52199999982258, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 248320 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 51.498000000137836, + "self_cpu_time_us": 44.30700000032084, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 1, + 456, + 248320 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 7.190999999816995, + "self_cpu_time_us": 7.190999999816995, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 248320 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 34.92900000006193, + "self_cpu_time_us": 26.077000000106636, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 456, + 248320 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 8.851999999955297, + "self_cpu_time_us": 8.851999999955297, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [], + [], + [], + [], + [] + ], + "count": 24, + "cpu_time_us": 35024.91000000032, + "self_cpu_time_us": 98.8560000010184, + "cuda_time_us": 22.748999999661464, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::lift_fresh", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ] + ], + "count": 8, + "cpu_time_us": 2.2850000001490116, + "self_cpu_time_us": 2.2850000001490116, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ] + ], + "count": 8, + "cpu_time_us": 25.912999999767635, + "self_cpu_time_us": 11.841000000073109, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "detach_", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ] + ], + "count": 8, + "cpu_time_us": 14.071999999694526, + "self_cpu_time_us": 14.071999999694526, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 248320 + ], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 5.820000000065193, + "self_cpu_time_us": 5.820000000065193, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [] + ], + "count": 8, + "cpu_time_us": 25.552000000083353, + "self_cpu_time_us": 11.651000000012573, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 181.6590000001015, + "self_cpu_time_us": 14.137000000162516, + "cuda_time_us": 12.510999999882188, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::softmax", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [] + ], + "count": 8, + "cpu_time_us": 190.901000000129, + "self_cpu_time_us": 28.746000000159256, + "cuda_time_us": 8.638000000501052, + "self_cuda_time_us": 0.0 + }, + { + "op": "aten::resolve_conj", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ] + ], + "count": 8, + "cpu_time_us": 3.743999999947846, + "self_cpu_time_us": 3.743999999947846, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::resolve_neg", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ] + ], + "count": 8, + "cpu_time_us": 2.2919999998412095, + "self_cpu_time_us": 2.2919999998412095, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [ + [ + 3 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "count": 8, + "cpu_time_us": 263.9090000001015, + "self_cpu_time_us": 12.896999999938998, + "cuda_time_us": 7.551000000210479, + "self_cuda_time_us": 0.0 + }, + { + "op": "Buffer Flush", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 7, + "cpu_time_us": 628.0309999997262, + "self_cpu_time_us": 596.3359999998356, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + }, + { + "op": "cudaDeviceSynchronize", + "device_type": "DeviceType.CPU", + "is_user_annotation": false, + "input_shapes": [], + "count": 2, + "cpu_time_us": 18.873000000137836, + "self_cpu_time_us": 18.873000000137836, + "cuda_time_us": 0, + "self_cuda_time_us": 0 + } + ] + } + } + ], + "environment": { + "python": "3.12.13", + "gpu": "NVIDIA GeForce RTX 4090", + "compute_capability": [ + 8, + 9 + ], + "cuda": "13.0", + "driver": "595.71.05", + "torch_num_threads": 64, + "torch_num_interop_threads": 64, + "packages": { + "torch": "2.14.0", + "torchvision": "0.29.0", + "transformers": "5.17.0", + "peft": "0.21.0", + "pillow": "11.3.0", + "safetensors": "0.8.0", + "triton": "3.8.0" + }, + "reference_revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f", + "base_revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", + "adapter_revision": "16818868b0cc7813808aae4e87b417657046ab79", + "dtype": "bfloat16", + "adapter_merged": false + }, + "load_ms": 19466.146210208535, + "adapter_modules": 178 +} diff --git a/recipe/cua_s1/experiments/rtx4090-profile/traces.log b/recipe/cua_s1/experiments/rtx4090-profile/traces.log new file mode 100644 index 0000000..7fdfbcb --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-profile/traces.log @@ -0,0 +1,12 @@ +[transformers] `torch_dtype` is deprecated! Use `dtype` instead! + Loading weights: 0%| | 0/723 [00:00 Date: Mon, 28 Sep 2026 11:40:16 +0800 Subject: [PATCH 05/26] docs: plan request-local image reuse experiment --- .../plans/2026-09-28-cua-image-reuse.md | 17 +++++++++++++++++ .../specs/2026-09-28-cua-image-reuse-design.md | 9 +++++++++ 2 files changed, 26 insertions(+) create mode 100644 docs/superpowers/plans/2026-09-28-cua-image-reuse.md create mode 100644 docs/superpowers/specs/2026-09-28-cua-image-reuse-design.md diff --git a/docs/superpowers/plans/2026-09-28-cua-image-reuse.md b/docs/superpowers/plans/2026-09-28-cua-image-reuse.md new file mode 100644 index 0000000..ef18c27 --- /dev/null +++ b/docs/superpowers/plans/2026-09-28-cua-image-reuse.md @@ -0,0 +1,17 @@ +# Cua-S1 Image Reuse Implementation Plan + +> **For agentic workers:** Use subagent-driven-development for implementation and independent review; controller owns GPU experiments and publication. + +**Goal:** Complete request-local image reuse with reproducible correctness and speed evidence, submit a PR, then shut down the GPU server. + +**Architecture:** Keep existing prepare/score as the reference path. Add isolated image preparation reuse and shared visual features for multi-question predict. Build per-question embeddings and positions using pinned model helpers. + +**Tech Stack:** Python, PyTorch 2.14, Transformers 5.17, PEFT 0.21, RTX 4090. + +- [ ] Baseline: run all tests/cua_s1; preserve existing PR #15 data. +- [ ] Implementation: tests/cua_s1/test_image_reuse.py first; prove failures; implement src/models/cua_s1/multimodal/model.py and focused helper module if needed. Preserve preflight validation, distinct prompts, no shared mutable state, PEFT vision layers and unchanged single-question behavior. +- [ ] Harness: recipe/cua_s1/benchmark_image_reuse.py plus CPU tests. Check exact tensors, positions and probabilities before timed paired measurements; alternate order; record each sample and independent per-variant peak memory. Retain failed reports. Reuse profile_multimodal fixture and provenance helpers. +- [ ] GPU: use clean committed checkout, run CPU tests, correctness smoke then 16-case paired experiment (5 warmups, 2 x 50 iterations per variant), plus distinct questions. Separate count/trace verification from all timed calls. +- [ ] Review: independent spec review followed by quality review; resolve findings and re-run affected checks. +- [ ] Publication: document measured results and tensor contract, retain raw JSON, run lint/full tests, commit/push and create linked PR identifying #12/#15 dependencies. +- [ ] Shutdown: copy experiment artifacts locally, verify hashes, confirm no required GPU work remains, shut down server and verify provider/connection state. diff --git a/docs/superpowers/specs/2026-09-28-cua-image-reuse-design.md b/docs/superpowers/specs/2026-09-28-cua-image-reuse-design.md new file mode 100644 index 0000000..324407a --- /dev/null +++ b/docs/superpowers/specs/2026-09-28-cua-image-reuse-design.md @@ -0,0 +1,9 @@ +# Request-local Cua-S1 image reuse + +Approved scope: implement the proposed single-request preprocessing and vision reuse, verify exact correctness and paired RTX 4090 performance, publish a PR, back up results and shut down the experiment server. + +Reuse the single image within a parsed Request. Preserve each question's full processor tokenization, candidate readout, token accounting and three-dimensional positions. Validate every processed length before any vision or language execution. Keep the unmodified single-question path and an explicit baseline path for experiments. The shared visual encoder includes all active PEFT adapters. Never cache text embeddings, positions or outputs across questions or images. Do not introduce a cross-request cache, batching, adapter merging or approximate arithmetic. + +Preprocessing should reuse the pinned processor's image result through a request-local processor copy, without changing global modules. Vision reuse should compute the image features once, build question-specific embeddings and explicit positions through the pinned model helpers, then invoke the existing PEFT model with inputs_embeds. Record the concrete tensor interface and ownership in the recipe documentation. + +Acceptance: exact prepared tensor and candidate probability parity across distinct questions, varying candidate counts/order, image sizes/formats and consecutive different-image requests; one preprocessing and one vision execution per multi-question request; failure cleanup; no single-question regression outside measurement noise. Measure the existing 16-case matrix using paired alternating baseline/candidate calls, plus a distinct-question workload. Save raw samples, environment, source revisions, memory peaks and commands. Counts and optional trace verification run outside latency measurements. Publish without claiming native backend or kernel optimization. From 8c3aa2054030770c783c0c1237298d4d32eb25ca Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 11:43:35 +0800 Subject: [PATCH 06/26] test: add paired image reuse experiment and correctness checks --- recipe/cua_s1/benchmark_image_reuse.py | 323 +++++++++++++++++++++++++ tests/cua_s1/test_reuse_benchmark.py | 117 +++++++++ 2 files changed, 440 insertions(+) create mode 100644 recipe/cua_s1/benchmark_image_reuse.py create mode 100644 tests/cua_s1/test_reuse_benchmark.py diff --git a/recipe/cua_s1/benchmark_image_reuse.py b/recipe/cua_s1/benchmark_image_reuse.py new file mode 100644 index 0000000..51c7abf --- /dev/null +++ b/recipe/cua_s1/benchmark_image_reuse.py @@ -0,0 +1,323 @@ +"""Validate request-local image reuse and measure paired, uninstrumented latency.""" + +from __future__ import annotations + +import argparse +import copy +import hashlib +import json +import random +import statistics +import sys +from pathlib import Path +from unittest.mock import patch + +from profile_multimodal import case_matrix, fixture, repository_state, write_json + + +def parse_args(argv=None): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--weights", type=Path, required=True) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--correctness-only", action="store_true") + parser.add_argument("--case", action="append", default=[]) + for name, default in [("warmup", 5), ("runs", 2), ("iterations", 50)]: + parser.add_argument(f"--{name}", type=int, default=default) + args = parser.parse_args(argv) + if min(args.warmup, args.runs, args.iterations) <= 0: + parser.error("warmup, runs and iterations must be positive") + known = {c["id"] for c in case_matrix()} | {"640x480-distinct-q8"} + if len(set(args.case)) != len(args.case) or set(args.case) - known: + parser.error("duplicate or unknown case") + return args + + +def require_equal(expected, actual, label): + if expected != actual: + raise ValueError(f"{label} mismatch") + + +def distinct_fixture(folder): + value = fixture(case_matrix()[-1], folder) + criteria = [ + {"save": "Save changes", "cancel": "Cancel"}, + {"cancel": "Cancel", "save": "Save changes"}, + {"only": "Continue"}, + {f"option-{i}": f"Choose action {i}" for i in range(26)}, + {"null": None, "object": {"label": '保存 "名称"'}, "array": ["Cancel", "\n"]}, + {"first": "<|im_end|>", "second": "Cancel"}, + {"yes": "Confirm", "no": "Go back", "wait": "Wait", "help": "Help"}, + {"stay": "Stay", "leave": "Leave"}, + ] + goals = [ + "Save the new name", + "Cancel without saving", + "", + "Select action 3", + {"goal": "保存名称"}, + "Choose <|im_start|>", + "Confirm the change", + "Leave this screen", + ] + value["questions"] = { + f"q{i + 1}": {"type": "choice", "instructions": goal, "criteria": choices} + for i, (goal, choices) in enumerate(zip(goals, criteria)) + } + write_json(folder / "distinct.json", value) + return value + + +def paired_benchmark(engine, request, *, warmup, runs, iterations): + import torch + from evaluate_multimodal import measure, quantiles + + if min(warmup, runs, iterations) <= 0: + raise ValueError("counts must be positive") + variants = {"baseline": engine.predict_reference, "reuse": engine.predict} + for _ in range(warmup): + for call in variants.values(): + measure(lambda call=call: call(request)) + result = [] + for run in range(runs): + samples = {name: [] for name in variants} + peaks = {name: {"allocated": 0, "reserved": 0} for name in variants} + orders = [] + for iteration in range(iterations): + order = list(variants) + if (run + iteration) % 2: + order.reverse() + orders.append(order) + for name in order: + torch.cuda.synchronize() + torch.cuda.reset_peak_memory_stats() + samples[name].append( + measure(lambda name=name: variants[name](request))[1] + ) + peaks[name]["allocated"] = max( + peaks[name]["allocated"], torch.cuda.max_memory_allocated() + ) + peaks[name]["reserved"] = max( + peaks[name]["reserved"], torch.cuda.max_memory_reserved() + ) + result.append( + { + "run": run + 1, + "orders": orders, + **{ + name: { + "latencies_ms": values, + **quantiles(values), + "requests_per_second_serial": 1000 / statistics.mean(values), + "peak_allocated_bytes": peaks[name]["allocated"], + "peak_reserved_bytes": peaks[name]["reserved"], + } + for name, values in samples.items() + }, + } + ) + return result + + +def observed_predict(engine, request, call): + """Untimed real processor/module counts and language input fingerprints.""" + import torch + from evaluate_multimodal import fingerprint + + counts = {"vision": 0, "language": 0} + language_inputs = [] + core = engine.model.get_base_model().model + + def vision(module, args): + counts["vision"] += 1 + + def language(module, args, kwargs): + counts["language"] += 1 + language_inputs.append( + fingerprint( + { + name: kwargs[name] + for name in ("inputs_embeds", "position_ids", "attention_mask") + if kwargs.get(name) is not None + } + ) + ) + + handles = [ + core.visual.register_forward_pre_hook(vision), + core.language_model.register_forward_pre_hook(language, with_kwargs=True), + ] + try: + with patch.object( + engine.processor.image_processor, + "preprocess", + wraps=engine.processor.image_processor.preprocess, + ) as prepare: + output = call(request) + torch.cuda.synchronize() + counts["image_preprocess"] = prepare.call_count + finally: + for handle in handles: + handle.remove() + return output, counts, language_inputs + + +def validate_case(engine, request): + from evaluate_multimodal import fingerprint + + expected_inputs = [ + fingerprint(engine.prepare(request.image, q)) for q in request.questions + ] + actual_inputs = [ + fingerprint(x) for x in engine.prepare_reused(request.image, request.questions) + ] + require_equal(expected_inputs, actual_inputs, "prepared tensors") + baseline, baseline_counts, baseline_language = observed_predict( + engine, request, engine.predict_reference + ) + reuse, reuse_counts, reuse_language = observed_predict( + engine, request, engine.predict + ) + require_equal(baseline, reuse, "full response / probabilities") + require_equal( + baseline_language, reuse_language, "language embeddings / 3D positions" + ) + n = len(request.questions) + require_equal( + {"image_preprocess": n, "vision": n, "language": n}, + baseline_counts, + "baseline calls", + ) + require_equal( + {"image_preprocess": 1, "vision": 1, "language": n}, reuse_counts, "reuse calls" + ) + return { + "exact_prepared_tensor_parity": True, + "exact_response_parity": True, + "exact_language_input_parity": True, + "baseline_counts": baseline_counts, + "reuse_counts": reuse_counts, + "inputs": actual_inputs, + "language_inputs": reuse_language, + "response": reuse, + } + + +def correctness_cases(folder): + from evaluate_multimodal import cases + + result = [(name, value) for name, _, value in cases(folder)] + distinct = distinct_fixture(folder / "distinct") + result.append(("distinct-eight", distinct)) + reverse = copy.deepcopy(distinct) + reverse["questions"] = dict(reversed(list(reverse["questions"].items()))) + result.append(("distinct-reversed", reverse)) + # Same varied prompts but another image and grid; then return to original image. + changed = copy.deepcopy(distinct) + changed["state"] = result[0][1]["state"] + result.extend( + [("distinct-small-image", changed), ("distinct-original-again", distinct)] + ) + return result + + +def main(argv=None): + args = parse_args(argv) + path = args.output / "report.json" + if path.exists(): + raise ValueError("output report already exists; use a fresh directory") + args.output.mkdir(parents=True, exist_ok=True) + report = { + "schema_version": 1, + "status": "running", + "repository": repository_state(Path(__file__).resolve().parents[2]), + "config": { + "warmup": args.warmup, + "runs": args.runs, + "iterations": args.iterations, + "correctness_only": args.correctness_only, + "selected_cases": args.case, + "case_order_seed": 20260928, + "concurrency": 1, + "batch_size": 1, + "timed_scope": "synchronized engine.predict; excludes HTTP, parsing, image decode, validation instrumentation", + }, + "correctness": [], + "cases": [], + } + write_json(path, report) + try: + from evaluate_multimodal import environment, measure + + from models.cua_s1.multimodal.model import MultimodalEngine + from models.cua_s1.multimodal.protocol import parse_request + + report["environment"] = environment() + engine, report["load_ms"] = measure( + lambda: MultimodalEngine( + str(args.weights / "Qwen3.5-4B"), + str(args.weights / "cua-s1-4b-0.2/multimodal"), + ) + ) + report["adapter_modules"] = engine.adapter_modules + for name, value in correctness_cases(args.output / "correctness-fixtures"): + checked = validate_case(engine, parse_request(value)) + report["correctness"].append({"id": name, **checked}) + write_json(path, report) + print( + f"correctness {name}: exact tensors, embeddings, positions, responses; {checked['reuse_counts']}", + flush=True, + ) + if not args.correctness_only: + selected = case_matrix() + [{"id": "640x480-distinct-q8"}] + selected = [c for c in selected if not args.case or c["id"] in args.case] + random.Random(20260928).shuffle(selected) + for case in selected: + value = ( + distinct_fixture(args.output / "fixtures") + if case["id"] == "640x480-distinct-q8" + else fixture(case, args.output / "fixtures") + ) + request = parse_request(value) + item = { + **case, + "status": "running", + "fixture_sha256": hashlib.sha256( + json.dumps(value, sort_keys=True).encode() + ).hexdigest(), + } + report["cases"].append(item) + write_json(path, report) + item["validation"] = validate_case(engine, request) + item["runs"] = paired_benchmark( + engine, + request, + warmup=args.warmup, + runs=args.runs, + iterations=args.iterations, + ) + item["status"] = "complete" + write_json(path, report) + print( + f"benchmark {case['id']}: " + + json.dumps( + [ + {v: round(r[v]["p50_ms"], 2) for v in ("baseline", "reuse")} + for r in item["runs"] + ] + ), + flush=True, + ) + report["status"] = "complete" + except Exception as exc: + report.update( + status="failed", error={"type": type(exc).__name__, "message": str(exc)} + ) + print(f"Experiment failed: {report['error']}", file=sys.stderr, flush=True) + raise + finally: + write_json(path, report) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tests/cua_s1/test_reuse_benchmark.py b/tests/cua_s1/test_reuse_benchmark.py new file mode 100644 index 0000000..c6ff810 --- /dev/null +++ b/tests/cua_s1/test_reuse_benchmark.py @@ -0,0 +1,117 @@ +"""Contracts for paired measurements, fixture diversity, and saved failures.""" + +import importlib.util +import sys +from pathlib import Path +from types import SimpleNamespace + +import pytest + +RECIPE = Path(__file__).resolve().parents[2] / "recipe/cua_s1" + + +@pytest.fixture +def reuse_benchmark(monkeypatch): + monkeypatch.syspath_prepend(str(RECIPE)) + path = RECIPE / "benchmark_image_reuse.py" + assert path.exists(), "reuse benchmark is not implemented" + spec = importlib.util.spec_from_file_location("reuse_benchmark", path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def test_distinct_fixture_changes_goals_and_candidate_layout(reuse_benchmark, tmp_path): + from models.cua_s1.multimodal.protocol import parse_request + + value = reuse_benchmark.distinct_fixture(tmp_path) + request = parse_request(value) + assert len(request.questions) == 8 + assert len({q.goal for q in request.questions}) == 8 + assert len({len(q.keys) for q in request.questions}) >= 3 + assert any(len(q.keys) == 26 for q in request.questions) + + +def test_paired_measurements_alternate_and_keep_variant_peaks( + reuse_benchmark, monkeypatch +): + events = [] + cuda = SimpleNamespace( + synchronize=lambda: events.append("sync"), + reset_peak_memory_stats=lambda: events.append("reset"), + max_memory_allocated=lambda: 123, + max_memory_reserved=lambda: 456, + ) + monkeypatch.setitem(sys.modules, "torch", SimpleNamespace(cuda=cuda)) + engine = SimpleNamespace( + predict_reference=lambda request: events.append("baseline"), + predict=lambda request: events.append("reuse"), + ) + result = reuse_benchmark.paired_benchmark( + engine, None, warmup=1, runs=2, iterations=2 + ) + calls = [event for event in events if event in {"baseline", "reuse"}] + assert calls == [ + "baseline", + "reuse", + "baseline", + "reuse", + "reuse", + "baseline", + "reuse", + "baseline", + "baseline", + "reuse", + ] + assert events.count("reset") == 8 + assert len(result) == 2 + for run in result: + for variant in ("baseline", "reuse"): + assert len(run[variant]["latencies_ms"]) == 2 + assert run[variant]["peak_allocated_bytes"] == 123 + assert run[variant]["peak_reserved_bytes"] == 456 + + +@pytest.mark.parametrize("option", ["--warmup", "--runs", "--iterations"]) +def test_nonpositive_benchmark_counts_rejected(reuse_benchmark, option): + with pytest.raises(SystemExit): + reuse_benchmark.parse_args( + ["--weights", "/tmp/w", "--output", "/tmp/o", option, "0"] + ) + + +def test_input_mismatch_does_not_pass_validation(reuse_benchmark): + with pytest.raises(ValueError, match="mismatch"): + reuse_benchmark.require_equal({"x": 1}, {"x": 2}, "inputs") + + +def test_failure_report_is_preserved(reuse_benchmark, monkeypatch, tmp_path): + import json + + import evaluate_multimodal + + from models.cua_s1.multimodal import model + + monkeypatch.setattr(evaluate_multimodal, "environment", lambda: {"gpu": "fake"}) + monkeypatch.setattr(evaluate_multimodal, "measure", lambda call: (call(), 0.0)) + monkeypatch.setattr( + model, "MultimodalEngine", lambda *args: SimpleNamespace(adapter_modules=178) + ) + monkeypatch.setattr( + reuse_benchmark, "correctness_cases", lambda folder: [("bad", {})] + ) + with pytest.raises(ValueError): + reuse_benchmark.main( + [ + "--weights", + str(tmp_path), + "--output", + str(tmp_path), + "--correctness-only", + ] + ) + report = json.loads((tmp_path / "report.json").read_text()) + assert report["status"] == "failed" + assert report["error"]["type"] == "InvalidRequest" + with pytest.raises(ValueError, match="already exists"): + reuse_benchmark.main(["--weights", str(tmp_path), "--output", str(tmp_path)]) From 7e7ed3478a3fb2b3886bd077dc8cd72e01174f0d Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 11:44:11 +0800 Subject: [PATCH 07/26] test: preserve unoptimized profiling baseline after reuse --- recipe/cua_s1/profile_multimodal.py | 3 +++ tests/cua_s1/test_profiling.py | 40 +++++++++++++++++++++++++++++ 2 files changed, 43 insertions(+) diff --git a/recipe/cua_s1/profile_multimodal.py b/recipe/cua_s1/profile_multimodal.py index 38a6b59..960201c 100644 --- a/recipe/cua_s1/profile_multimodal.py +++ b/recipe/cua_s1/profile_multimodal.py @@ -387,6 +387,9 @@ def main(argv=None): str(args.weights / "cua-s1-4b-0.2/multimodal"), ) ) + # Preserve this recipe as the unoptimized stage baseline from PR #15. + if hasattr(engine, "predict_reference"): + engine.predict = engine.predict_reference report["adapter_modules"] = engine.adapter_modules for case in selected: current = {**case, "status": "running"} diff --git a/tests/cua_s1/test_profiling.py b/tests/cua_s1/test_profiling.py index 5cd1991..cd1f48d 100644 --- a/tests/cua_s1/test_profiling.py +++ b/tests/cua_s1/test_profiling.py @@ -467,3 +467,43 @@ def profile(*args): assert report["status"] == ("failed" if profile_fails else "complete") saved = json.loads((tmp_path / f"{case}.json").read_text()) assert saved["status"] == ("failed" if profile_fails else "complete") + + +def test_profile_recipe_selects_unoptimized_reference(profiling, monkeypatch, tmp_path): + import evaluate_multimodal + + from models.cua_s1.multimodal import model + + def reference(request): + return "baseline" + + engine = SimpleNamespace( + adapter_modules=178, + predict_reference=reference, + predict=lambda request: "optimized", + ) + monkeypatch.setattr(model, "MultimodalEngine", lambda *args: engine) + monkeypatch.setattr(evaluate_multimodal, "environment", lambda: {}) + monkeypatch.setattr(evaluate_multimodal, "measure", lambda call: (call(), 0.0)) + monkeypatch.setattr( + profiling, "input_metadata", lambda *args: [{"input_tokens": 1}] + ) + + def benchmark(selected_engine, *args, **kwargs): + assert selected_engine.predict(None) == "baseline" + return {"runs": []} + + monkeypatch.setattr(profiling, "benchmark", benchmark) + assert ( + profiling.main( + [ + "--weights", + str(tmp_path), + "--output", + str(tmp_path), + "--case", + "320x240-short-q1", + ] + ) + == 0 + ) From 7874c6cd51151a206236cc967cbb6f8ad20639f9 Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 11:44:44 +0800 Subject: [PATCH 08/26] style: simplify profiling test environment stub --- tests/cua_s1/test_profiling.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/cua_s1/test_profiling.py b/tests/cua_s1/test_profiling.py index cd1f48d..39871cd 100644 --- a/tests/cua_s1/test_profiling.py +++ b/tests/cua_s1/test_profiling.py @@ -483,7 +483,7 @@ def reference(request): predict=lambda request: "optimized", ) monkeypatch.setattr(model, "MultimodalEngine", lambda *args: engine) - monkeypatch.setattr(evaluate_multimodal, "environment", lambda: {}) + monkeypatch.setattr(evaluate_multimodal, "environment", dict) monkeypatch.setattr(evaluate_multimodal, "measure", lambda call: (call(), 0.0)) monkeypatch.setattr( profiling, "input_metadata", lambda *args: [{"input_tokens": 1}] From cf899ffca186bae158b756316685226f99ca8b75 Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 11:44:56 +0800 Subject: [PATCH 09/26] Reuse image preprocessing and adapted vision features within requests --- src/models/cua_s1/multimodal/model.py | 104 ++++++++++++- tests/cua_s1/test_image_reuse.py | 204 ++++++++++++++++++++++++++ tests/cua_s1/test_model.py | 2 +- 3 files changed, 306 insertions(+), 4 deletions(-) create mode 100644 tests/cua_s1/test_image_reuse.py diff --git a/src/models/cua_s1/multimodal/model.py b/src/models/cua_s1/multimodal/model.py index db55070..625c8c0 100644 --- a/src/models/cua_s1/multimodal/model.py +++ b/src/models/cua_s1/multimodal/model.py @@ -2,6 +2,7 @@ from __future__ import annotations +import copy import hashlib import json from pathlib import Path @@ -77,6 +78,24 @@ def verify_weights(base: Path, adapter: Path): ) +class _RequestImageProcessor: + """Reuse one image result; each processor call owns its mutable mapping.""" + + def __init__(self, processor): + self.processor = processor + self.result = None + + def __getattr__(self, name): + return getattr(self.processor, name) + + def __call__(self, *args, **kwargs): + if self.result is None: + self.result = self.processor(*args, **kwargs) + # BatchFeature.to and processor token expansion can mutate mappings. + # Share only tensor values, which the pinned processor does not modify. + return type(self.result)(dict(self.result)) + + class MultimodalEngine: def __init__( self, base: str, adapter: str, device: str = "cuda", dtype: str = "bfloat16" @@ -118,15 +137,74 @@ def __init__( self.dtype = dtype def prepare(self, image, question: Question): + return self._prepare(self.processor, image, question) + + @staticmethod + def _prepare(processor, image, question: Question): messages = build_messages(question) - text = self.processor.apply_chat_template( + text = processor.apply_chat_template( messages, tokenize=False, add_generation_prompt=True ) - inputs = self.processor(text=[text], images=[image], return_tensors="pt") + inputs = processor(text=[text], images=[image], return_tensors="pt") if inputs["input_ids"].shape[-1] > MAX_TOKENS: raise InvalidRequest(f"processed prompt exceeds {MAX_TOKENS} tokens") return inputs + def prepare_reused(self, image, questions): + """Tokenize each question normally, preprocessing this request's image once.""" + processor = copy.copy(self.processor) + processor.image_processor = _RequestImageProcessor( + self.processor.image_processor + ) + return [self._prepare(processor, image, question) for question in questions] + + def encode_image(self, inputs): + """Encode once through the vision modules with their active LoRA adapters.""" + import torch + + core = self.model.get_base_model().model + with torch.no_grad(): + output = core.get_image_features( + inputs["pixel_values"].to(self.model.device), + inputs["image_grid_thw"].to(self.model.device), + return_dict=True, + ) + return torch.cat(output.pooler_output, dim=0) + + def score_reused(self, inputs, question: Question, features) -> list[float]: + """Build fresh text embeddings and 3D positions around shared image features.""" + import torch + + ids = letter_ids(self.tokenizer, len(question.keys)) + # Keep prepared CPU inputs intact and avoid another image transfer. + text_inputs = { + key: value.to(self.model.device) + for key, value in inputs.items() + if key != "pixel_values" + } + core = self.model.get_base_model().model + with torch.no_grad(): + input_ids = text_inputs.pop("input_ids") + embeds = core.get_input_embeddings()(input_ids) + image_embeds = features.to(embeds.device, embeds.dtype) + image_mask, _ = core.get_placeholder_mask( + input_ids, inputs_embeds=embeds, image_features=image_embeds + ) + embeds = embeds.masked_scatter(image_mask, image_embeds) + position_ids, _ = core.get_rope_index( + input_ids=input_ids, + mm_token_type_ids=text_inputs.pop("mm_token_type_ids"), + image_grid_thw=text_inputs.pop("image_grid_thw"), + attention_mask=text_inputs.get("attention_mask"), + ) + output = self.model( + inputs_embeds=embeds, position_ids=position_ids, **text_inputs + ) + logits = output.logits[0, -1, :] + return torch.softmax( + logits[torch.tensor(ids, device=logits.device)].float(), dim=-1 + ).tolist() + def score(self, inputs, question: Question) -> list[float]: import torch @@ -139,7 +217,8 @@ def score(self, inputs, question: Question) -> list[float]: logits[torch.tensor(ids, device=logits.device)].float(), dim=-1 ).tolist() - def predict(self, request: Request) -> dict: + def predict_reference(self, request: Request) -> dict: + """Original full-processor/full-model path retained for paired experiments.""" # Validate all processed lengths before executing any question. prepared = [self.prepare(request.image, q) for q in request.questions] answers = { @@ -155,6 +234,25 @@ def predict(self, request: Request) -> dict: }, } + def predict(self, request: Request) -> dict: + if len(request.questions) == 1: + return self.predict_reference(request) + # No image encoder or language model runs until every prompt is valid. + prepared = self.prepare_reused(request.image, request.questions) + features = self.encode_image(prepared[0]) + answers = { + q.name: answer(q, self.score_reused(inputs, q, features)) + for q, inputs in zip(request.questions, prepared) + } + return { + "model": IDENTITY, + "answers": answers, + "usage": { + "input_tokens": sum(x["input_ids"].shape[-1] for x in prepared), + "output_tokens": 0, + }, + } + def warmup(self): from PIL import Image diff --git a/tests/cua_s1/test_image_reuse.py b/tests/cua_s1/test_image_reuse.py new file mode 100644 index 0000000..5c497a2 --- /dev/null +++ b/tests/cua_s1/test_image_reuse.py @@ -0,0 +1,204 @@ +"""Request ownership tests, plus tensor integration tests when torch is installed.""" + +from types import SimpleNamespace + +import pytest + +from models.cua_s1.multimodal.model import MAX_TOKENS, MultimodalEngine +from models.cua_s1.multimodal.protocol import InvalidRequest, Question, Request + +QUESTIONS = ( + Question("first", ("yes", "no"), ("Yes", "No"), "Confirm"), + Question("second", ("back", "next", "stop"), ("Back", "Next", "Stop"), "Go back"), +) + + +class ImageProcessor: + merge_size = 2 + + def __init__(self): + self.calls = [] + + def __call__(self, images, **kwargs): + self.calls.append(images[0]) + return {"pixel_values": images[0], "image_grid_thw": (1, 4, 4)} + + +class Processor: + def __init__(self): + self.image_processor = ImageProcessor() + self.calls = [] + self.fail = False + + def apply_chat_template(self, messages, **kwargs): + return repr(messages) + + def __call__(self, text, images, **kwargs): + assert self.image_processor.merge_size == 2 + image = self.image_processor(images, return_tensors="pt") + # Processor implementations may consume/mutate their returned mapping. + pixels = image.pop("pixel_values") + self.calls.append(text[0]) + if self.fail: + raise ValueError("tokenizer failure") + return { + "pixel_values": pixels, + "image_grid_thw": image["image_grid_thw"], + "input_ids": SimpleNamespace(shape=(1, len(text[0]))), + "text": text[0], + } + + +def engine_with_processor(): + engine = object.__new__(MultimodalEngine) + engine.processor = Processor() + return engine + + +def test_preprocessing_reuses_only_image_and_keeps_question_prompts(): + engine = engine_with_processor() + original = engine.processor.image_processor + image = object() + prepared = engine.prepare_reused(image, QUESTIONS) + assert original.calls == [image] + assert prepared[0]["pixel_values"] is prepared[1]["pixel_values"] is image + assert prepared[0]["text"] != prepared[1]["text"] + assert engine.processor.image_processor is original + for question, inputs in zip(QUESTIONS, prepared): + reference = engine.prepare(image, question) + assert inputs["text"] == reference["text"] + assert inputs["input_ids"].shape == reference["input_ids"].shape + assert inputs["image_grid_thw"] == reference["image_grid_thw"] + + +def test_image_cache_does_not_survive_requests_or_failed_preparation(): + engine = engine_with_processor() + images = [object(), object(), object()] + engine.prepare_reused(images[0], QUESTIONS) + engine.processor.fail = True + with pytest.raises(ValueError, match="tokenizer failure"): + engine.prepare_reused(images[1], QUESTIONS) + engine.processor.fail = False + prepared = engine.prepare_reused(images[2], QUESTIONS) + assert engine.processor.image_processor.calls == images + assert all(x["pixel_values"] is images[2] for x in prepared) + + +def test_all_lengths_checked_before_vision_or_language_execution(): + engine = engine_with_processor() + forwarded = [] + engine.encode_image = lambda inputs: forwarded.append("vision") + engine.score_reused = lambda *args: forwarded.append("language") + long = Question("long", ("a",), ("A",), "x" * MAX_TOKENS) + with pytest.raises(InvalidRequest, match="4096"): + engine.predict(Request(object(), (QUESTIONS[0], long))) + assert forwarded == [] + + +def test_multi_question_prediction_encodes_once_and_keeps_usage(): + engine = engine_with_processor() + encoded, scored = [], [] + features = object() + + def encode(inputs): + encoded.append(inputs) + return features + + def score(inputs, question, shared): + assert shared is features + scored.append(question) + return [1 / len(question.keys)] * len(question.keys) + + engine.encode_image = encode + engine.score_reused = score + request = Request(object(), QUESTIONS) + result = engine.predict(request) + assert len(encoded) == 1 + assert scored == list(QUESTIONS) + assert list(result["answers"]) == [q.name for q in QUESTIONS] + assert result["usage"]["input_tokens"] == sum( + x["input_ids"].shape[-1] + for x in engine.prepare_reused(request.image, QUESTIONS) + ) + + +def test_single_question_uses_reference_path(): + engine = object.__new__(MultimodalEngine) + request = Request(object(), QUESTIONS[:1]) + calls = [] + engine.predict_reference = lambda value: calls.append(value) or {"reference": True} + assert engine.predict(request) == {"reference": True} + assert calls == [request] + + +def test_reused_tensor_path_preserves_scatter_positions_and_peft_forward(): + torch = pytest.importorskip("torch") + engine = object.__new__(MultimodalEngine) + calls = [] + features = torch.tensor([[10.0, 20.0], [30.0, 40.0]]) + positions = torch.tensor([[[0, 1, 1, 3]], [[0, 1, 1, 3]], [[0, 1, 2, 3]]]) + + class Core: + def get_image_features(self, pixels, grid, return_dict): + assert not torch.is_grad_enabled() + calls.append("vision-with-adapters") + return SimpleNamespace(pooler_output=(features,)) + + def get_input_embeddings(self): + return lambda ids: ids.unsqueeze(-1).expand(-1, -1, 2).float() + + def get_placeholder_mask(self, ids, inputs_embeds, image_features): + assert torch.equal(image_features, features) + return (ids == 9).unsqueeze(-1).expand_as(inputs_embeds), None + + def get_rope_index(self, **kwargs): + assert torch.equal( + kwargs["mm_token_type_ids"], torch.tensor([[0, 1, 1, 0]]) + ) + assert torch.equal(kwargs["input_ids"], torch.tensor([[1, 9, 9, 2]])) + calls.append("positions") + return positions, torch.tensor([[0]]) + + class Peft: + device = "cpu" + + def get_base_model(self): + return SimpleNamespace(model=Core()) + + def __call__(self, **kwargs): + assert not torch.is_grad_enabled() + assert "input_ids" not in kwargs and "pixel_values" not in kwargs + assert "image_grid_thw" not in kwargs + assert torch.equal(kwargs["position_ids"], positions) + assert torch.equal( + kwargs["inputs_embeds"], + torch.tensor([[[1.0, 1.0], [10.0, 20.0], [30.0, 40.0], [2.0, 2.0]]]), + ) + calls.append("peft-forward") + return SimpleNamespace(logits=torch.tensor([[[0.0, 1.0, 2.0]]])) + + engine.model = Peft() + engine.tokenizer = SimpleNamespace(encode=lambda text, **kwargs: [ord(text) - 65]) + inputs = { + "input_ids": torch.tensor([[1, 9, 9, 2]]), + "mm_token_type_ids": torch.tensor([[0, 1, 1, 0]]), + "attention_mask": torch.ones((1, 4), dtype=torch.long), + "pixel_values": torch.ones(2, 4), + "image_grid_thw": torch.tensor([[1, 2, 4]]), + } + original = {key: value.clone() for key, value in inputs.items()} + shared = engine.encode_image(inputs) + for question in QUESTIONS: + result = engine.score_reused(inputs, question, shared) + assert ( + result + == torch.softmax(torch.arange(len(question.keys)).float(), dim=-1).tolist() + ) + assert calls == [ + "vision-with-adapters", + "positions", + "peft-forward", + "positions", + "peft-forward", + ] + assert all(torch.equal(value, original[key]) for key, value in inputs.items()) diff --git a/tests/cua_s1/test_model.py b/tests/cua_s1/test_model.py index 228e3ac..77f4390 100644 --- a/tests/cua_s1/test_model.py +++ b/tests/cua_s1/test_model.py @@ -108,5 +108,5 @@ def prepare(image, question): engine.prepare = prepare engine.score = lambda inputs, q: forwarded.append(q) with pytest.raises(InvalidRequest, match="4096"): - engine.predict(Request(None, (first, second))) + engine.predict_reference(Request(None, (first, second))) assert forwarded == [] From c18a21b205d7a66449de845a8598b6e27d82424c Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 11:46:48 +0800 Subject: [PATCH 10/26] test: cover multi-question JPEG reuse and document tensor contract --- recipe/cua_s1/benchmark_image_reuse.py | 3 + recipe/cua_s1/image-reuse.md | 77 ++++++++++++++++++++++++++ tests/cua_s1/test_reuse_benchmark.py | 12 ++++ 3 files changed, 92 insertions(+) create mode 100644 recipe/cua_s1/image-reuse.md diff --git a/recipe/cua_s1/benchmark_image_reuse.py b/recipe/cua_s1/benchmark_image_reuse.py index 51c7abf..6425127 100644 --- a/recipe/cua_s1/benchmark_image_reuse.py +++ b/recipe/cua_s1/benchmark_image_reuse.py @@ -208,6 +208,9 @@ def correctness_cases(folder): result = [(name, value) for name, _, value in cases(folder)] distinct = distinct_fixture(folder / "distinct") result.append(("distinct-eight", distinct)) + jpeg = copy.deepcopy(distinct) + jpeg["state"] = dict(result)["jpeg"]["state"] + result.append(("distinct-jpeg", jpeg)) reverse = copy.deepcopy(distinct) reverse["questions"] = dict(reversed(list(reverse["questions"].items()))) result.append(("distinct-reversed", reverse)) diff --git a/recipe/cua_s1/image-reuse.md b/recipe/cua_s1/image-reuse.md new file mode 100644 index 0000000..b937e42 --- /dev/null +++ b/recipe/cua_s1/image-reuse.md @@ -0,0 +1,77 @@ +# Request-local image reuse + +`MultimodalEngine.predict` reuses image preprocessing and the adapted visual +encoder for requests containing 2–8 questions. A one-question request keeps the +original path. Every question still has its own prompt, tokenization, candidate +ordering, input embeddings, three-dimensional positions, language forward and +readout. All processed token limits are checked before any model execution. + +`predict_reference` retains the original implementation for paired measurements. +`profile_multimodal.py` explicitly selects it so the PR #15 stage baseline remains +reproducible. The model identity, HTTP request/response and usage contract do not +change. This is a Transformers/PEFT execution optimization, not a native CUDA +backend, a custom kernel, batching or a cross-request cache. + +## Reuse boundary and tensor ownership + +The implementation targets the pinned Transformers 5.17.0 Qwen3.5 model and +processor. A shallow processor copy owns a request-local image-processor proxy. +Its first invocation executes the original image processor; later invocations +return fresh mappings over the same image tensors. The full original processor +still expands image placeholders and tokenizes every question. Neither the +shared processor nor model methods are replaced. + +| Value | Contract | Owner and lifetime | +| --- | --- | --- | +| `pixel_values` | Processor-produced patch tensor, unchanged shape/dtype/layout | CPU tensor shared only among prepared inputs in this request; transferred once for the shared visual forward | +| `image_grid_thw` | Integer `[1, 3]` temporal/height/width grid from the same processor call | Shared CPU metadata; transferred for visual encoding and each question's position construction | +| Visual features | Concatenated `get_image_features(...).pooler_output`, `[image_tokens, text_hidden_size]`; active vision LoRA layers included | Request-local device tensor under `no_grad`; converted to each question embedding dtype/device before scatter | +| `input_ids`, `attention_mask`, `mm_token_type_ids` | Full processor outputs, constructed independently for each prompt | Per-question mappings; image reuse does not replace text tokenization | +| `inputs_embeds` | `[1, sequence_length, text_hidden_size]`, new token embeddings with image placeholders filled by `masked_scatter` | Per-question device tensor; feature/placeholder count checked by the model helper | +| `position_ids` | Integer `[3, 1, sequence_length]` from the original `get_rope_index` using that question's tokens, modality types, grid and mask | Per-question device tensor passed explicitly to the full PEFT model; never reused | + +No manual allocator, custom CUDA stream, KV-cache reuse or persistent feature +cache is introduced. Ordinary PyTorch references own the tensors; request-local +references disappear on return or exception. The CUDA allocator may retain +reserved memory. The existing server serializes inference. Native-engine +handoff and its stream/allocator contract remain future work. + +## Correctness and performance experiment + +```sh +PYTHONPATH=src python recipe/cua_s1/benchmark_image_reuse.py \ + --weights /path/to/weights --output /path/to/fresh-results \ + --warmup 5 --runs 2 --iterations 50 +``` + +Use `--correctness-only` for a smoke run; `--case ID` selects performance cases. +Output directories cannot overwrite an existing report. Exceptions leave a +failed report with completed results intact. + +Before timing, compare the reference and optimized paths for exact prepared +input fingerprints, language input embeddings, 3D positions, attention masks, +candidate probabilities and full responses. Count actual image preprocessing, +visual and language invocations using temporary test instrumentation. This +instrumentation is removed before timed calls. Correctness cases include PNG, +JPEG, different image sizes, 1 and 26 candidates, reordered candidates, structured +and Unicode labels, accepted text control tokens, eight distinct questions, +reversed question order and consecutive requests changing image/grid then +returning to the original image. CPU tests also cover preparation failures and +token-limit rejection before inference. + +The performance matrix retains all 16 original size/length/question-count cases +and adds a distinct-question case. Shuffle case order with recorded seed +20260928. Each case warms both paths, then alternates baseline/reuse and +reuse/baseline for each sample, reversing the starting order for the second run. +Each sample synchronizes CUDA around the whole `predict` call. Reset memory +peaks for each variant invocation and retain raw latencies, execution order, +per-variant allocated/reserved peaks, environment and source revision. + +Timing excludes HTTP, queuing, JSON parsing, image decoding, instrumentation, +input fingerprinting and model loading. Results apply to concurrency 1 and +controlled synthetic screenshots; they do not establish GUI task accuracy, +service throughput, p99 or maximum supported input sizes. Reserved-memory peaks +may carry over between variants, so allocated peaks are the useful comparison. +Single-question paths are identical and their measured differences represent +noise. Numerical equality is tested for this pinned environment, not guaranteed +for arbitrary library versions, adapters or devices. diff --git a/tests/cua_s1/test_reuse_benchmark.py b/tests/cua_s1/test_reuse_benchmark.py index c6ff810..d595283 100644 --- a/tests/cua_s1/test_reuse_benchmark.py +++ b/tests/cua_s1/test_reuse_benchmark.py @@ -115,3 +115,15 @@ def test_failure_report_is_preserved(reuse_benchmark, monkeypatch, tmp_path): assert report["error"]["type"] == "InvalidRequest" with pytest.raises(ValueError, match="already exists"): reuse_benchmark.main(["--weights", str(tmp_path), "--output", str(tmp_path)]) + + +def test_jpeg_fixture_exercises_multiple_questions(reuse_benchmark, tmp_path): + from models.cua_s1.multimodal.protocol import parse_request + + cases = dict(reuse_benchmark.correctness_cases(tmp_path)) + assert "distinct-jpeg" in cases + request = parse_request(cases["distinct-jpeg"]) + assert len(request.questions) == 8 + assert cases["distinct-jpeg"]["state"]["image"].startswith( + "data:image/jpeg;base64," + ) From 4bb4035ab0348615f680c4fb7cc9e7e0cee720b2 Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 11:47:16 +0800 Subject: [PATCH 11/26] Test image reuse cleanup after inference failures --- tests/cua_s1/test_image_reuse.py | 63 ++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/tests/cua_s1/test_image_reuse.py b/tests/cua_s1/test_image_reuse.py index 5c497a2..4d3eac5 100644 --- a/tests/cua_s1/test_image_reuse.py +++ b/tests/cua_s1/test_image_reuse.py @@ -1,5 +1,7 @@ """Request ownership tests, plus tensor integration tests when torch is installed.""" +import gc +import weakref from types import SimpleNamespace import pytest @@ -84,6 +86,67 @@ def test_image_cache_does_not_survive_requests_or_failed_preparation(): assert all(x["pixel_values"] is images[2] for x in prepared) +@pytest.mark.parametrize("failure_stage", ["encode", "second_question"]) +def test_failed_inference_releases_request_state_before_different_image(failure_stage): + engine = engine_with_processor() + processor = engine.processor + image_processor = processor.image_processor + failed_image, next_image = object(), object() + encoded_images, feature_refs, scored = [], [], [] + + class Features: + def __init__(self, image): + self.image = image + + def encode(inputs): + image = inputs["pixel_values"] + encoded_images.append(image) + features = Features(image) + feature_refs.append(weakref.ref(features)) + if image is failed_image and failure_stage == "encode": + raise RuntimeError("encoder failure") + return features + + def score(inputs, question, features): + image = inputs["pixel_values"] + assert features.image is image + assert features is feature_refs[-1]() + scored.append((image, question.name)) + if image is failed_image and question is QUESTIONS[1]: + raise RuntimeError("later question failure") + return [1 / len(question.keys)] * len(question.keys) + + engine.encode_image = encode + engine.score_reused = score + original_engine_state = dict(vars(engine)) + message = ( + "encoder failure" if failure_stage == "encode" else "later question failure" + ) + with pytest.raises(RuntimeError, match=message): + engine.predict(Request(failed_image, QUESTIONS)) + gc.collect() + assert all(ref() is None for ref in feature_refs) + assert vars(engine) == original_engine_state + assert engine.processor is processor + assert processor.image_processor is image_processor + assert image_processor.calls == [failed_image] + assert scored == ( + [] if failure_stage == "encode" else [(failed_image, q.name) for q in QUESTIONS] + ) + + result = engine.predict(Request(next_image, QUESTIONS)) + gc.collect() + assert encoded_images == [failed_image, next_image] + assert image_processor.calls == [failed_image, next_image] + assert scored[-2:] == [(next_image, q.name) for q in QUESTIONS] + assert list(result["answers"]) == [q.name for q in QUESTIONS] + assert len(feature_refs) == 2 + assert all(ref() is None for ref in feature_refs) + assert vars(engine) == original_engine_state + assert engine.processor is processor + assert processor.image_processor is image_processor + + def test_all_lengths_checked_before_vision_or_language_execution(): engine = engine_with_processor() forwarded = [] From 0abf31d01a7f0a80e431806a7ccb9481c2610ea7 Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 11:50:48 +0800 Subject: [PATCH 12/26] Avoid body-write race in transport rejection tests --- tests/cua_s1/test_server.py | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/tests/cua_s1/test_server.py b/tests/cua_s1/test_server.py index fef1f3c..5d2eee2 100644 --- a/tests/cua_s1/test_server.py +++ b/tests/cua_s1/test_server.py @@ -1,3 +1,4 @@ +import http.client import json import threading import urllib.error @@ -144,6 +145,20 @@ def unexpected(_): ], ) def test_transport_errors_use_detail(worker, route, body, headers, status): - _, url = worker - actual, response = call(url + route, body, **headers) - assert actual == status and set(response) == {"detail"} + server, _ = worker + connection = http.client.HTTPConnection("127.0.0.1", server.server_port, timeout=5) + try: + connection.putrequest("GET" if body is None else "POST", route) + request_headers = {"Content-Type": "application/json", **headers} + if body is not None and "Transfer-Encoding" not in headers: + request_headers.setdefault("Content-Length", str(len(json.dumps(body)))) + for name, value in request_headers.items(): + connection.putheader(name, value) + # Every case rejects from headers. Sending a body (especially a final + # chunk terminator) can race the server's early response and close. + connection.endheaders() + with connection.getresponse() as response: + assert response.status == status + assert set(json.load(response)) == {"detail"} + finally: + connection.close() From d0c4781d99ca47c9527c0e09f58d3c04d84726e2 Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 11:56:39 +0800 Subject: [PATCH 13/26] docs: link request reuse behavior and record completed reviews --- docs/superpowers/plans/2026-09-28-cua-image-reuse.md | 8 ++++---- recipe/cua_s1/README.md | 6 ++++-- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/docs/superpowers/plans/2026-09-28-cua-image-reuse.md b/docs/superpowers/plans/2026-09-28-cua-image-reuse.md index ef18c27..043b90e 100644 --- a/docs/superpowers/plans/2026-09-28-cua-image-reuse.md +++ b/docs/superpowers/plans/2026-09-28-cua-image-reuse.md @@ -8,10 +8,10 @@ **Tech Stack:** Python, PyTorch 2.14, Transformers 5.17, PEFT 0.21, RTX 4090. -- [ ] Baseline: run all tests/cua_s1; preserve existing PR #15 data. -- [ ] Implementation: tests/cua_s1/test_image_reuse.py first; prove failures; implement src/models/cua_s1/multimodal/model.py and focused helper module if needed. Preserve preflight validation, distinct prompts, no shared mutable state, PEFT vision layers and unchanged single-question behavior. -- [ ] Harness: recipe/cua_s1/benchmark_image_reuse.py plus CPU tests. Check exact tensors, positions and probabilities before timed paired measurements; alternate order; record each sample and independent per-variant peak memory. Retain failed reports. Reuse profile_multimodal fixture and provenance helpers. +- [x] Baseline: run all tests/cua_s1; preserve existing PR #15 data. +- [x] Implementation: tests/cua_s1/test_image_reuse.py first; prove failures; implement src/models/cua_s1/multimodal/model.py and focused helper module if needed. Preserve preflight validation, distinct prompts, no shared mutable state, PEFT vision layers and unchanged single-question behavior. +- [x] Harness: recipe/cua_s1/benchmark_image_reuse.py plus CPU tests. Check exact tensors, positions and probabilities before timed paired measurements; alternate order; record each sample and independent per-variant peak memory. Retain failed reports. Reuse profile_multimodal fixture and provenance helpers. - [ ] GPU: use clean committed checkout, run CPU tests, correctness smoke then 16-case paired experiment (5 warmups, 2 x 50 iterations per variant), plus distinct questions. Separate count/trace verification from all timed calls. -- [ ] Review: independent spec review followed by quality review; resolve findings and re-run affected checks. +- [x] Review: independent spec review followed by quality review; resolve findings and re-run affected checks. - [ ] Publication: document measured results and tensor contract, retain raw JSON, run lint/full tests, commit/push and create linked PR identifying #12/#15 dependencies. - [ ] Shutdown: copy experiment artifacts locally, verify hashes, confirm no required GPU work remains, shut down server and verify provider/connection state. diff --git a/recipe/cua_s1/README.md b/recipe/cua_s1/README.md index 6dac894..d8f14c4 100644 --- a/recipe/cua_s1/README.md +++ b/recipe/cua_s1/README.md @@ -97,8 +97,10 @@ Each answer has `type`, `choice`, `probabilities` and `confidence`. The readout uses the last position's candidate-letter logits, casts to fp32 and applies softmax over those letters only. There is no decode. Ties select the earliest option; confidence is `1 - H(p)/ln(n)`, or 1 for one option. Each question has a -separate forward pass over the same screenshot. Usage sums processed input tokens -and reports zero output tokens. +separate language forward pass. Multi-question requests reuse the image +preprocessing and adapted vision features within the request; see the +[reuse contract and experiment](image-reuse.md). Usage sums processed input +tokens and reports zero output tokens. Response identity: `cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal`. From 209a660852d7c4172bcf4cf4025e8333755ef2ec Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 12:02:19 +0800 Subject: [PATCH 14/26] test: add reproducible result audit and CUDA HTTP postflight --- .../experiments/rtx4090-reuse/postflight.py | 90 ++++++++++++++++ .../rtx4090-reuse/verify_results.py | 100 ++++++++++++++++++ 2 files changed, 190 insertions(+) create mode 100644 recipe/cua_s1/experiments/rtx4090-reuse/postflight.py create mode 100644 recipe/cua_s1/experiments/rtx4090-reuse/verify_results.py diff --git a/recipe/cua_s1/experiments/rtx4090-reuse/postflight.py b/recipe/cua_s1/experiments/rtx4090-reuse/postflight.py new file mode 100644 index 0000000..a8dbfb0 --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-reuse/postflight.py @@ -0,0 +1,90 @@ +"""Capture concrete tensor layout and verify the actual HTTP worker on CUDA.""" + +import json +import sys +import threading +import urllib.request +from pathlib import Path + +from benchmark_image_reuse import distinct_fixture, require_equal +from evaluate_multimodal import environment +from profile_multimodal import repository_state, write_json + +from models.cua_s1.multimodal.model import MultimodalEngine +from models.cua_s1.multimodal.protocol import parse_request +from models.cua_s1.multimodal.server import WorkerServer + +root, weights, output = map(Path, sys.argv[1:]) +output.mkdir(parents=True, exist_ok=True) +report = {"repository": repository_state(root), "environment": environment()} +engine = MultimodalEngine( + str(weights / "Qwen3.5-4B"), str(weights / "cua-s1-4b-0.2/multimodal") +) +value = distinct_fixture(output / "fixture") +request = parse_request(value) +prepared = engine.prepare_reused(request.image, request.questions) +features = engine.encode_image(prepared[0]) + + +def metadata(t): + return { + "shape": list(t.shape), + "dtype": str(t.dtype), + "device": str(t.device), + "stride": list(t.stride()), + "contiguous": t.is_contiguous(), + "requires_grad": t.requires_grad, + "bytes": t.numel() * t.element_size(), + } + + +report["cpu_inputs"] = {k: metadata(t) for k, t in prepared[0].items()} +report["shared_features"] = metadata(features) +core = engine.model.get_base_model().model +positions = [] + + +def capture(module, args, kwargs): + positions.append( + { + k: metadata(kwargs[k]) + for k in ("inputs_embeds", "position_ids", "attention_mask") + } + ) + + +handle = core.language_model.register_forward_pre_hook(capture, with_kwargs=True) +try: + expected = engine.predict(request) +finally: + handle.remove() +report["per_question_language_layouts"] = positions +del prepared, features +server = WorkerServer(("127.0.0.1", 0), engine) +thread = threading.Thread(target=server.serve_forever, daemon=True) +thread.start() +try: + address = f"http://127.0.0.1:{server.server_port}" + with urllib.request.urlopen(address + "/health", timeout=30) as response: + report["health"] = {"status": response.status, "body": json.load(response)} + req = urllib.request.Request( + address + "/v1/systemone", + data=json.dumps(value).encode(), + headers={"Content-Type": "application/json"}, + ) + with urllib.request.urlopen(req, timeout=60) as response: + actual = json.load(response) + require_equal(expected, actual, "HTTP response") + report["http"] = { + "status": response.status, + "exact_engine_parity": True, + "question_count": len(actual["answers"]), + "response": actual, + } +finally: + server.shutdown() + server.server_close() + thread.join() +report["status"] = "complete" +write_json(output / "postflight.json", report) +print("CUDA tensor layout and HTTP q8 exact parity complete", flush=True) diff --git a/recipe/cua_s1/experiments/rtx4090-reuse/verify_results.py b/recipe/cua_s1/experiments/rtx4090-reuse/verify_results.py new file mode 100644 index 0000000..6c4f589 --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-reuse/verify_results.py @@ -0,0 +1,100 @@ +"""Independently check saved samples and parity evidence, then print the table.""" + +import json +import math +import statistics +from pathlib import Path + +ROOT = Path(__file__).resolve().parent + + +def main(): + report = json.loads((ROOT / "paired.json").read_text()) + reference = json.loads((ROOT.parent / "rtx4090-profile/reference.json").read_text()) + assert report["status"] == "complete" + assert report["repository"]["dirty"] is False + assert report["environment"] == reference["environment"] + assert len(report["cases"]) == 17 + assert len(report["correctness"]) == 13 + original = {case["id"]: case for case in report["correctness"]} + for case in reference["cases"]: + checked = original[case["name"]] + answers = checked["response"]["answers"] + assert ( + list(answers[case["question"]]["probabilities"].values()) + == case["probabilities"] + ) + index = list(answers).index(case["question"]) + assert checked["inputs"][index] == case["inputs"] + count = 0 + for checked in report["correctness"] + [c["validation"] for c in report["cases"]]: + assert checked["exact_prepared_tensor_parity"] + assert checked["exact_language_input_parity"] + assert checked["exact_response_parity"] + n = len(checked["response"]["answers"]) + assert checked["baseline_counts"] == { + "image_preprocess": n, + "vision": n, + "language": n, + } + assert checked["reuse_counts"] == { + "image_preprocess": 1, + "vision": 1, + "language": n, + } + print( + "| Case | Baseline p50 ms | Reuse p50 ms | p50 reduction | Baseline p95 ms | Reuse p95 ms | Peak allocated GiB, baseline → reuse |" + ) + print("| --- | ---: | ---: | ---: | ---: | ---: | ---: |") + for case in sorted(report["cases"], key=lambda c: c["id"]): + assert case["status"] == "complete" + assert len(case["runs"]) == report["config"]["runs"] == 2 + for index, run in enumerate(case["runs"]): + for iteration, order in enumerate(run["orders"]): + expected = ["baseline", "reuse"] + if (index + iteration) % 2: + expected.reverse() + assert order == expected + for name in ("baseline", "reuse"): + values = run[name]["latencies_ms"] + assert ( + len(values) + == len(run["orders"]) + == report["config"]["iterations"] + == 50 + ) + assert all(math.isfinite(v) and v > 0 for v in values) + assert statistics.median(values) == run[name]["p50_ms"] + assert ( + sorted(values)[math.ceil(0.95 * len(values)) - 1] + == run[name]["p95_ms"] + ) + assert ( + run[name]["peak_reserved_bytes"] + >= run[name]["peak_allocated_bytes"] + > 0 + ) + count += len(values) + + def times(name, percentile): + return " / ".join(f"{r[name][percentile]:.2f}" for r in case["runs"]) + + reduction = " / ".join( + f"{100 * (1 - r['reuse']['p50_ms'] / r['baseline']['p50_ms']):.1f}%" + for r in case["runs"] + ) + memory = " → ".join( + f"{max(r[name]['peak_allocated_bytes'] for r in case['runs']) / 2**30:.3f}" + for name in ("baseline", "reuse") + ) + print( + f"| {case['id']} | {times('baseline', 'p50_ms')} | {times('reuse', 'p50_ms')} | {reduction} | {times('baseline', 'p95_ms')} | {times('reuse', 'p95_ms')} | {memory} |" + ) + assert count == 3400 + print( + f"\nVerified {count} timed requests, 13 correctness fixtures, 17 paired cases, and all 9 saved upstream forwards." + ) + + +if __name__ == "__main__": + main() From 9f4a4fe887b071d50d51e9e76eb6e07c8ae401e5 Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 12:12:20 +0800 Subject: [PATCH 15/26] test: audit exact coverage of the paired workload matrix --- recipe/cua_s1/experiments/rtx4090-reuse/verify_results.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/recipe/cua_s1/experiments/rtx4090-reuse/verify_results.py b/recipe/cua_s1/experiments/rtx4090-reuse/verify_results.py index 6c4f589..4c84f80 100644 --- a/recipe/cua_s1/experiments/rtx4090-reuse/verify_results.py +++ b/recipe/cua_s1/experiments/rtx4090-reuse/verify_results.py @@ -14,6 +14,13 @@ def main(): assert report["status"] == "complete" assert report["repository"]["dirty"] is False assert report["environment"] == reference["environment"] + expected_cases = { + f"{size}-{goal}-q{questions}" + for size in ("320x240", "640x480") + for goal in ("short", "long") + for questions in (1, 2, 4, 8) + } | {"640x480-distinct-q8"} + assert {case["id"] for case in report["cases"]} == expected_cases assert len(report["cases"]) == 17 assert len(report["correctness"]) == 13 original = {case["id"]: case for case in report["correctness"]} From ccaa4fb7c306c8409b5b0d0f466922866a5f892e Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 12:25:03 +0800 Subject: [PATCH 16/26] docs: record paired RTX 4090 image reuse results and exact parity --- .../plans/2026-09-28-cua-image-reuse.md | 2 +- .../experiments/rtx4090-reuse/README.md | 151 + .../experiments/rtx4090-reuse/SHA256SUMS | 6 + .../experiments/rtx4090-reuse/candidate.json | 536 + .../experiments/rtx4090-reuse/cpu-tests.log | 3 + .../experiments/rtx4090-reuse/paired.json | 21606 ++++++++++++++++ .../experiments/rtx4090-reuse/paired.log | 34 + .../experiments/rtx4090-reuse/postflight.json | 656 + .../experiments/rtx4090-reuse/reference.json | 527 + .../rtx4090-reuse/verify_results.py | 2 +- recipe/cua_s1/image-reuse.md | 2 + 11 files changed, 23523 insertions(+), 2 deletions(-) create mode 100644 recipe/cua_s1/experiments/rtx4090-reuse/README.md create mode 100644 recipe/cua_s1/experiments/rtx4090-reuse/SHA256SUMS create mode 100644 recipe/cua_s1/experiments/rtx4090-reuse/candidate.json create mode 100644 recipe/cua_s1/experiments/rtx4090-reuse/cpu-tests.log create mode 100644 recipe/cua_s1/experiments/rtx4090-reuse/paired.json create mode 100644 recipe/cua_s1/experiments/rtx4090-reuse/paired.log create mode 100644 recipe/cua_s1/experiments/rtx4090-reuse/postflight.json create mode 100644 recipe/cua_s1/experiments/rtx4090-reuse/reference.json diff --git a/docs/superpowers/plans/2026-09-28-cua-image-reuse.md b/docs/superpowers/plans/2026-09-28-cua-image-reuse.md index 043b90e..383b830 100644 --- a/docs/superpowers/plans/2026-09-28-cua-image-reuse.md +++ b/docs/superpowers/plans/2026-09-28-cua-image-reuse.md @@ -11,7 +11,7 @@ - [x] Baseline: run all tests/cua_s1; preserve existing PR #15 data. - [x] Implementation: tests/cua_s1/test_image_reuse.py first; prove failures; implement src/models/cua_s1/multimodal/model.py and focused helper module if needed. Preserve preflight validation, distinct prompts, no shared mutable state, PEFT vision layers and unchanged single-question behavior. - [x] Harness: recipe/cua_s1/benchmark_image_reuse.py plus CPU tests. Check exact tensors, positions and probabilities before timed paired measurements; alternate order; record each sample and independent per-variant peak memory. Retain failed reports. Reuse profile_multimodal fixture and provenance helpers. -- [ ] GPU: use clean committed checkout, run CPU tests, correctness smoke then 16-case paired experiment (5 warmups, 2 x 50 iterations per variant), plus distinct questions. Separate count/trace verification from all timed calls. +- [x] GPU: use clean committed checkout, run CPU tests, correctness smoke then 16-case paired experiment (5 warmups, 2 x 50 iterations per variant), plus distinct questions. Separate count/trace verification from all timed calls. - [x] Review: independent spec review followed by quality review; resolve findings and re-run affected checks. - [ ] Publication: document measured results and tensor contract, retain raw JSON, run lint/full tests, commit/push and create linked PR identifying #12/#15 dependencies. - [ ] Shutdown: copy experiment artifacts locally, verify hashes, confirm no required GPU work remains, shut down server and verify provider/connection state. diff --git a/recipe/cua_s1/experiments/rtx4090-reuse/README.md b/recipe/cua_s1/experiments/rtx4090-reuse/README.md new file mode 100644 index 0000000..10b0e10 --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-reuse/README.md @@ -0,0 +1,151 @@ +# RTX 4090 request-local image reuse — 2026-09-28 + +The optimized worker preprocesses and encodes a shared screenshot once per +multi-question request, retaining independent text processing, three-dimensional +positions, language forwards and candidate readouts. Single-question execution +uses the original path. + +Across the 13 multi-question cases (two runs each), measured p50 latency fell +**6.8–19.9%**. For **eight distinct questions on a 640×480 screenshot**, p50 fell +from **1100.03 / 1094.87 ms to 887.54 / 888.45 ms** (19.3% / 18.9% lower latency). +These are end-to-end `engine.predict` measurements, not extrapolations from +profiler stage spans. Single-question p50 differences ranged from 0.5% slower to +1.1% faster across identical execution paths and are treated as measurement noise. + +## Provenance and method + +- Timed source: clean `c18a21b205d7a66449de845a8598b6e27d82424c`; inference implementation + commit `cf899ff`. Later changes add tests, documentation and result-verification + scripts without changing the measured model or benchmark paths. +- Final GPU-host tests, fresh upstream oracle and HTTP/layout validation use + clean source `9f4a4fe`. +- RTX 4090 24,564 MiB; driver 595.71.05, CUDA runtime 13.0, Python 3.12.13, + PyTorch 2.14.0, Transformers 5.17.0, PEFT 0.21.0. Full package/version and model + provenance are in [paired.json](paired.json). Environment matches the original + pinned upstream baseline. +- Unmerged BF16 model with fp32 LoRA branches; all 178 adapted modules present, + including the vision modules. PyTorch Gated DeltaNet/causal-convolution fallback + implementations and 64/64 PyTorch thread settings are unchanged. +- Original 16-case matrix plus one eight-distinct-question case. Five warmup + requests per variant per case, then two runs of 50 samples per variant: + **3,400 timed requests / 13,600 language forwards**. Cases use recorded shuffled + order; baseline/reuse ordering alternates each sample and reverses per run. +- Timing synchronizes CUDA around each whole prediction, excluding HTTP, parsing, + image decoding, fingerprinting, hooks and model load. Reset peak memory before + each variant invocation. No profiler or counting hooks are installed during + latency sampling. Reserved memory can carry across variants; compare allocated + memory. Largest allocated peak: 9.083 GiB baseline, 9.035 GiB reuse. + +## Correctness and service validation + +- **13 correctness fixtures / 49 question forwards per path**, including eight + different questions, PNG/JPEG, different image/grid sizes, reversed question + order, 1–26 candidates, candidate reordering, Unicode/structured labels and + consecutive image changes. The same validation also runs on all 17 timed cases. +- Prepared tensor fingerprints, language input embeddings, 3D positions, + attention masks, candidate probabilities and complete responses are **exactly + equal** between original and optimized paths. No tolerance or approximation is + used. Actual multi-question image-preprocessing and vision counts fall from N + to 1; language counts remain N. The raw report records these counts and hashes. +- Fresh pinned upstream [reference.json](reference.json) and worker + [candidate.json](candidate.json) revalidate all nine upstream forwards. The + independent result audit also compares the optimized report with that oracle. +- Final GPU-host CPU suite: **104 passed**. Local macOS: **103 passed, 1 skipped** + (torch unavailable locally). The skipped tensor test runs on the GPU host. + Tests cover preflight token rejection, encoder/later-question failures, feature + lifetime and successful recovery with another image. Lint and formatting pass. +- [postflight.json](postflight.json) records actual tensor shape, dtype, strides, + contiguity and ownership-relevant metadata, plus HTTP health and eight-question + response equality against direct engine execution. + +## Paired latency and memory + +Values separated by `/` are run 1 / run 2. p95 is nearest rank over 50 samples; +allocated memory is the maximum across both runs. Negative reduction means slower. + +| Case | Baseline p50 ms | Reuse p50 ms | p50 reduction | Baseline p95 ms | Reuse p95 ms | Peak allocated GiB, baseline → reuse | +| --- | ---: | ---: | ---: | ---: | ---: | ---: | +| 320x240-long-q1 | 135.56 / 135.63 | 136.22 / 135.66 | -0.5% / -0.0% | 143.72 / 142.83 | 145.02 / 140.97 | 8.926 → 8.926 | +| 320x240-long-q2 | 286.12 / 271.52 | 261.18 / 251.31 | 8.7% / 7.4% | 329.01 / 337.47 | 272.06 / 312.39 | 8.931 → 8.922 | +| 320x240-long-q4 | 566.04 / 540.73 | 503.31 / 478.02 | 11.1% / 11.6% | 579.48 / 562.61 | 538.99 / 500.64 | 8.931 → 8.922 | +| 320x240-long-q8 | 1159.29 / 1137.77 | 967.33 / 950.53 | 16.6% / 16.5% | 1232.38 / 1236.30 | 1086.98 / 994.59 | 8.939 → 8.922 | +| 320x240-short-q1 | 108.11 / 108.17 | 108.09 / 108.04 | 0.0% / 0.1% | 112.40 / 113.68 | 109.76 / 116.19 | 8.728 → 8.728 | +| 320x240-short-q2 | 228.86 / 230.37 | 205.76 / 207.33 | 10.1% / 10.0% | 242.46 / 244.51 | 213.63 / 216.08 | 8.728 → 8.726 | +| 320x240-short-q4 | 448.85 / 443.57 | 382.62 / 379.76 | 14.8% / 14.4% | 464.28 / 470.91 | 395.06 / 394.91 | 8.734 → 8.726 | +| 320x240-short-q8 | 914.48 / 889.32 | 748.10 / 724.66 | 18.2% / 18.5% | 989.35 / 962.43 | 771.86 / 762.28 | 8.740 → 8.726 | +| 640x480-distinct-q8 | 1100.03 / 1094.87 | 887.54 / 888.45 | 19.3% / 18.9% | 1171.23 / 1162.61 | 984.33 / 963.19 | 9.015 → 8.992 | +| 640x480-long-q1 | 158.14 / 155.74 | 156.43 / 155.89 | 1.1% / -0.1% | 192.92 / 193.58 | 193.23 / 189.91 | 9.035 → 9.035 | +| 640x480-long-q2 | 309.13 / 310.54 | 286.97 / 289.53 | 7.2% / 6.8% | 325.38 / 330.10 | 298.02 / 302.77 | 9.043 → 9.033 | +| 640x480-long-q4 | 629.40 / 630.98 | 561.65 / 566.86 | 10.8% / 10.2% | 714.52 / 671.00 | 622.21 / 594.51 | 9.057 → 9.033 | +| 640x480-long-q8 | 1319.17 / 1316.22 | 1113.74 / 1112.65 | 15.6% / 15.5% | 1474.11 / 1446.67 | 1196.36 / 1159.36 | 9.083 → 9.033 | +| 640x480-short-q1 | 128.17 / 126.42 | 128.00 / 126.42 | 0.1% / 0.0% | 142.45 / 131.61 | 133.58 / 130.29 | 8.842 → 8.842 | +| 640x480-short-q2 | 256.55 / 256.11 | 234.05 / 236.78 | 8.8% / 7.6% | 270.34 / 273.75 | 240.42 / 250.98 | 8.849 → 8.838 | +| 640x480-short-q4 | 532.07 / 520.37 | 461.20 / 449.92 | 13.3% / 13.5% | 570.69 / 553.80 | 478.79 / 472.87 | 8.862 → 8.838 | +| 640x480-short-q8 | 1092.57 / 1096.68 | 874.72 / 891.88 | 19.9% / 18.7% | 1317.02 / 1271.33 | 954.19 / 933.10 | 8.890 → 8.838 | + +## Concrete feature interface + +For the 640×480 distinct-question fixture, the processor produces contiguous +CPU fp32 pixels `[1200, 1536]`. Shared adapted features are contiguous CUDA BF16 +`[300, 2560]`, stride `[2560, 1]`, 1,536,000 bytes, with gradients disabled. +The first question uses CUDA BF16 embeddings `[1, 443, 2560]` and CUDA int64 +positions `[3, 1, 443]`. All eight question layouts are recorded in +[postflight.json](postflight.json); sequence lengths remain question-specific. +These are measurements of the pinned processor/model, not a general native-engine +ABI. See [ownership and execution contract](../../image-reuse.md). + +## Reproduce and independently audit + +Run from the repository root with the pinned environment and downloaded weights. +The measured command was: + +```sh +PYTHONPATH=src /root/autodl-tmp/system1-omni-work/venv/bin/python \ + recipe/cua_s1/benchmark_image_reuse.py \ + --weights /root/autodl-tmp/system1-omni-work/weights \ + --output /root/autodl-tmp/system1-omni-work/experiments/20260928-reuse/paired \ + --warmup 5 --runs 2 --iterations 50 +``` + +Use a fresh output directory for a new run. Regenerate the independent oracle +with both `--mode reference` and `--mode candidate` in the same output directory: + +```sh +PYTHONPATH=src python recipe/cua_s1/evaluate_multimodal.py \ + --weights /path/to/weights --reference /path/to/pinned-cua-checkout \ + --output /path/to/fresh-oracle --mode reference +PYTHONPATH=src python recipe/cua_s1/evaluate_multimodal.py \ + --weights /path/to/weights --reference /path/to/pinned-cua-checkout \ + --output /path/to/fresh-oracle --mode candidate +PYTHONPATH=src:recipe/cua_s1 python \ + recipe/cua_s1/experiments/rtx4090-reuse/postflight.py \ + /path/to/system1-omni /path/to/weights /path/to/fresh-postflight +``` + +The saved dataset can be audited without torch, a GPU or model weights: + +```sh +python recipe/cua_s1/experiments/rtx4090-reuse/verify_results.py +``` + +This checks exact coverage of the 17 cases, all 3,400 sample values, alternating +order, medians and nearest-rank p95 calculations, memory bounds, invocation +counts, parity flags and all nine independent upstream input/probability records. +[SHA256SUMS](SHA256SUMS) identifies the public data files; [paired.log](paired.log) +and [cpu-tests.log](cpu-tests.log) retain execution progress and final test output. + +The complete raw outputs, generated fixtures, smoke run, oracle and HTTP logs +were also copied off the GPU host before shutdown in +`20260928-image-reuse-evidence.tar.gz`, SHA-256 +`65b365ecd10c49036519ac37e8a50bc6746f6630e0c98f03068ab39c4dd8f868`. +The table does not depend on that external archive; its raw samples are in Git. + +## Limits + +This is concurrency-1, prefill-only execution on synthetic screenshots and the +pinned software/hardware. It establishes no GUI task-quality improvement, HTTP +latency/throughput gain, p99 result, maximum input-size coverage, native CUDA +kernel speedup or Metal support. The HTTP postflight is a correctness check only. +Image preprocessing and visual encoding are reused inside one request; text +processing and language execution remain per question. No persistent cache, +batching, adapter merge, compiler or CUDA Graph change was made. diff --git a/recipe/cua_s1/experiments/rtx4090-reuse/SHA256SUMS b/recipe/cua_s1/experiments/rtx4090-reuse/SHA256SUMS new file mode 100644 index 0000000..b924f1f --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-reuse/SHA256SUMS @@ -0,0 +1,6 @@ +3820b048d75d59e117564e1ce88c50fc4a1b0ac7df4966f5f6aa2c079edffd15 paired.json +44e5b5e9e4439c39d4cfeefd38cdb7e99b55930203ddb33a4c576344d6f060b9 reference.json +75b3ea97632978d9260d6b5f6eccfb6a38e067d7b0e13540dd5d5ec4ffc97f20 candidate.json +b23b5a7aa0f427eefd3112847d944487b1d4f62c2964166f67fb68a4e5fcb1b4 postflight.json +8f99a4520eeef6a15de18f9f17ff42b8e52e4f2515313b6a6e1ff64e4b9ed374 paired.log +b2b06041ec7be5dfefee43314a4096b6476f8ca38396ad7ce4a6cc61f22ccb7c cpu-tests.log diff --git a/recipe/cua_s1/experiments/rtx4090-reuse/candidate.json b/recipe/cua_s1/experiments/rtx4090-reuse/candidate.json new file mode 100644 index 0000000..af1e58d --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-reuse/candidate.json @@ -0,0 +1,536 @@ +{ + "environment": { + "python": "3.12.13", + "gpu": "NVIDIA GeForce RTX 4090", + "compute_capability": [ + 8, + 9 + ], + "cuda": "13.0", + "driver": "595.71.05", + "torch_num_threads": 64, + "torch_num_interop_threads": 64, + "packages": { + "torch": "2.14.0", + "torchvision": "0.29.0", + "transformers": "5.17.0", + "peft": "0.21.0", + "pillow": "11.3.0", + "safetensors": "0.8.0", + "triton": "3.8.0" + }, + "reference_revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f", + "base_revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", + "adapter_revision": "16818868b0cc7813808aae4e87b417657046ab79", + "dtype": "bfloat16", + "adapter_merged": false + }, + "mode": "candidate", + "cases": [ + { + "name": "small", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + "probabilities": [ + 0.9958575367927551, + 0.0005507932510226965, + 0.003591623157262802 + ], + "max_abs_difference": 0.0, + "latency_ms": 131.62544276565313 + }, + { + "name": "medium", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 0.9958575367927551, + 0.0005507932510226965, + 0.003591623157262802 + ], + "max_abs_difference": 0.0, + "latency_ms": 132.84761272370815 + }, + { + "name": "jpeg", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 0.9936226010322571, + 0.0011634123511612415, + 0.005214052740484476 + ], + "max_abs_difference": 0.0, + "latency_ms": 131.22473284602165 + }, + { + "name": "single", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "c4d7b1102e94984504efa938052a0bba3639ba85f9917de3e8af5426ceefd16b" + }, + "attention_mask": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "3419eb840bd7f9d9e4b1fa6aaea783bae7a4752068701794687337702c2d8968" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "077d91126e88fd3e8ba97a2d8079c28a4d5da388e56c89ca0e584fd5ad4b3641" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 1.0 + ], + "max_abs_difference": 0.0, + "latency_ms": 123.72183427214622 + }, + { + "name": "26-options", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 0.07546718418598175, + 0.00034948240499943495, + 0.263406366109848, + 0.557631254196167, + 0.009013270027935505, + 0.01908109337091446, + 0.007019542157649994, + 0.016839005053043365, + 0.009013270027935505, + 0.0025823453906923532, + 0.004824455827474594, + 0.003315796609967947, + 0.002011132426559925, + 0.0022789116483181715, + 0.00619472423568368, + 0.0010764816543087363, + 0.0037572900764644146, + 0.0006529190577566624, + 0.002011132426559925, + 0.0012198134791105986, + 0.00044874430750496686, + 0.0005084939184598625, + 0.003315796609967947, + 0.0013822298496961594, + 0.0017748181708157063, + 0.004824455827474594 + ], + "max_abs_difference": 0.0, + "latency_ms": 145.9085550159216 + }, + { + "name": "structured", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 0.07443060725927353, + 0.9067503809928894, + 0.01881900243461132 + ], + "max_abs_difference": 0.0, + "latency_ms": 128.97435761988163 + }, + { + "name": "special-token", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + "probabilities": [ + 0.531209409236908, + 0.4687906503677368 + ], + "max_abs_difference": 0.0, + "latency_ms": 126.96553394198418 + }, + { + "name": "two-questions", + "question": "next", + "inputs": { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + "probabilities": [ + 0.9958575367927551, + 0.0005507932510226965, + 0.003591623157262802 + ], + "max_abs_difference": 0.0, + "latency_ms": 112.65888996422291 + }, + { + "name": "two-questions", + "question": "second", + "inputs": { + "input_ids": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "1bc665c3f5aa0134e368d1a9edf0e652ec604cf43e969d59b14f696a4cf5c9c3" + }, + "attention_mask": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "bbdd8ad88f622ea9585a6b471f3ef6810a0c3374e43dbcb747e3077de4e6e674" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "6dc930bb14d93a028e6d2db398b391c4fe5af99184ec6625d38d2f7820e182f3" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + "probabilities": [ + 0.22270014882087708, + 0.7772998809814453 + ], + "max_abs_difference": 0.0, + "latency_ms": 113.51354978978634 + } + ], + "reference_source": { + "path": "libs/cua-s1/python/src/cua_s1/four_b.py", + "sha256": "7ed1adfd92223bef7d533db7efbb4cbf468c4936c4380ae42aee12097e3b9ea7", + "revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f" + }, + "load_ms": 19002.971435897052, + "warmup_ms": 1797.259071841836, + "adapter_modules": 178, + "peak_allocated_bytes": 9657058304 +} \ No newline at end of file diff --git a/recipe/cua_s1/experiments/rtx4090-reuse/cpu-tests.log b/recipe/cua_s1/experiments/rtx4090-reuse/cpu-tests.log new file mode 100644 index 0000000..cec5638 --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-reuse/cpu-tests.log @@ -0,0 +1,3 @@ +........................................................................ [ 69%] +................................ [100%] +104 passed in 15.59s diff --git a/recipe/cua_s1/experiments/rtx4090-reuse/paired.json b/recipe/cua_s1/experiments/rtx4090-reuse/paired.json new file mode 100644 index 0000000..c72626c --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-reuse/paired.json @@ -0,0 +1,21606 @@ +{ + "schema_version": 1, + "status": "complete", + "repository": { + "revision": "c18a21b205d7a66449de845a8598b6e27d82424c", + "dirty": false, + "diff_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "untracked_files": [] + }, + "config": { + "warmup": 5, + "runs": 2, + "iterations": 50, + "correctness_only": false, + "selected_cases": [], + "case_order_seed": 20260928, + "concurrency": 1, + "batch_size": 1, + "timed_scope": "synchronized engine.predict; excludes HTTP, parsing, image decode, validation instrumentation" + }, + "correctness": [ + { + "id": "small", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + } + }, + "usage": { + "input_tokens": 236, + "output_tokens": 0 + } + } + }, + { + "id": "medium", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + } + }, + "usage": { + "input_tokens": 456, + "output_tokens": 0 + } + } + }, + { + "id": "jpeg", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "8563e2d6f4bc4a9c1a594d53c0c5c4062760ffca599922127b53e64df8986603" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9936226010322571, + "cancel": 0.0011634123511612415, + "wait": 0.005214052740484476 + }, + "confidence": 0.9621116268179815 + } + }, + "usage": { + "input_tokens": 456, + "output_tokens": 0 + } + } + }, + { + "id": "single", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "c4d7b1102e94984504efa938052a0bba3639ba85f9917de3e8af5426ceefd16b" + }, + "attention_mask": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "3419eb840bd7f9d9e4b1fa6aaea783bae7a4752068701794687337702c2d8968" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "077d91126e88fd3e8ba97a2d8079c28a4d5da388e56c89ca0e584fd5ad4b3641" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 431, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "637e12e3d1ac73afc9258c509ed8724b6171bae8a0ce5a39e870cf8c250442e6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "36312a68dabf34c5fdadce5e51ec9a97606fc7aa87087d166ca310623235d10d" + }, + "attention_mask": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "3419eb840bd7f9d9e4b1fa6aaea783bae7a4752068701794687337702c2d8968" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "only", + "probabilities": { + "only": 1.0 + }, + "confidence": 1.0 + } + }, + "usage": { + "input_tokens": 431, + "output_tokens": 0 + } + } + }, + { + "id": "26-options", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 752, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cd572e59171ef52d8e37644cbbdbbf9ff86d77d31cf48b19c4821d7349c026f7" + }, + "position_ids": { + "shape": [ + 3, + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "3d615db0cf3b07f33f32c5d24335f9abdd5b4599e5de79b20326f339520128d1" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "option-3", + "probabilities": { + "option-0": 0.07546718418598175, + "option-1": 0.00034948240499943495, + "option-2": 0.263406366109848, + "option-3": 0.557631254196167, + "option-4": 0.009013270027935505, + "option-5": 0.01908109337091446, + "option-6": 0.007019542157649994, + "option-7": 0.016839005053043365, + "option-8": 0.009013270027935505, + "option-9": 0.0025823453906923532, + "option-10": 0.004824455827474594, + "option-11": 0.003315796609967947, + "option-12": 0.002011132426559925, + "option-13": 0.0022789116483181715, + "option-14": 0.00619472423568368, + "option-15": 0.0010764816543087363, + "option-16": 0.0037572900764644146, + "option-17": 0.0006529190577566624, + "option-18": 0.002011132426559925, + "option-19": 0.0012198134791105986, + "option-20": 0.00044874430750496686, + "option-21": 0.0005084939184598625, + "option-22": 0.003315796609967947, + "option-23": 0.0013822298496961594, + "option-24": 0.0017748181708157063, + "option-25": 0.004824455827474594 + }, + "confidence": 0.5755459268738158 + } + }, + "usage": { + "input_tokens": 752, + "output_tokens": 0 + } + } + }, + { + "id": "structured", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 469, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "fecbffc833f744dd32c6b0296b399ef7256ded521c75fd8a5dfb2fd6f5e3c762" + }, + "position_ids": { + "shape": [ + 3, + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "a679452a2039eff05da911d8657b1857f058184d4bb373cd35576f7d3bfca410" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "object", + "probabilities": { + "null": 0.07443060725927353, + "object": 0.9067503809928894, + "array": 0.01881900243461132 + }, + "confidence": 0.6751463333759231 + } + }, + "usage": { + "input_tokens": 469, + "output_tokens": 0 + } + } + }, + { + "id": "special-token", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "a075316b24c03cafe09f612e8c4499e0c87035b098bf3db6f8023f7be18c405d" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "first", + "probabilities": { + "first": 0.531209409236908, + "second": 0.4687906503677368 + }, + "confidence": 0.002812297157495758 + } + }, + "usage": { + "input_tokens": 441, + "output_tokens": 0 + } + } + }, + { + "id": "two-questions", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 2, + "language": 2, + "image_preprocess": 2 + }, + "reuse_counts": { + "vision": 1, + "language": 2, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "1bc665c3f5aa0134e368d1a9edf0e652ec604cf43e969d59b14f696a4cf5c9c3" + }, + "attention_mask": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "bbdd8ad88f622ea9585a6b471f3ef6810a0c3374e43dbcb747e3077de4e6e674" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "6dc930bb14d93a028e6d2db398b391c4fe5af99184ec6625d38d2f7820e182f3" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 215, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "d12d91036735b6503b458045529a1f5368721c551fbcb0681196c8a70006fbb8" + }, + "position_ids": { + "shape": [ + 3, + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "58dafa9b49c13c2f1ae8214fb18e76b5d932313605785742a8a93415f8d954b3" + }, + "attention_mask": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "bbdd8ad88f622ea9585a6b471f3ef6810a0c3374e43dbcb747e3077de4e6e674" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "second": { + "type": "choice", + "choice": "no", + "probabilities": { + "yes": 0.22270014882087708, + "no": 0.7772998809814453 + }, + "confidence": 0.23493269546473194 + } + }, + "usage": { + "input_tokens": 451, + "output_tokens": 0 + } + } + }, + { + "id": "distinct-eight", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 8, + "language": 8, + "image_preprocess": 8 + }, + "reuse_counts": { + "vision": 1, + "language": 8, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "0d717f46abbc57e2696c66d4969fc777e96415a6f67740a7087cf77d78de218d" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "ff71ef4e6c311c56cd3dbe484f8a05773dba0361b21e97745ca7394758319d1c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "eb7ea7dd8487457bc025d44ba5ebc1550026250abea05f847d61b8ea6f52af8e" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "60b6d77d34ada12b8def875237be8cd0feee4475ccf4cb389bd44245b21a8f9d" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "c0e9e08d7a1863b1e91cca10457d593e1281ccd5695cfb89683b8121826cff38" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8de01e028cd92e75ba21cf901916223dc844a7c580f8bb2b943828403cb28198" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "cc047cd8ed2d1ddd4493abd7cff8ee7ba9fcd0b6265e1a1b8b4b2f6c6e822390" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "6fd0e47d02ff77335d5b2733962a9f7a1caed5ea867aa67b8c3b4b788509dba1" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "deb3cc137c72ac7e023b78a4d29d507ddf95f02f2572e38dd068a3574116ac21" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 443, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "c108e3059ad63ab2efd4d2d194766ab18ef6144819985ff6448dae85f476b032" + }, + "position_ids": { + "shape": [ + 3, + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "9e4fd6391bea467b1a278b2506d278b0ae583fc15a686a31882dc377374e04d1" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 442, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "db88bedddbbd1d2b6aaf63664379d5206b0de9ef3fcf0ccdd0fb951599364847" + }, + "position_ids": { + "shape": [ + 3, + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "f706ff63624d02735d39ebe7097dc53d833763276475713d80259d5fed6d7446" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 426, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "b464ff04b79496dcab96f3a8b588a4bc5e611075d4e44ff7b526eaa685658b4a" + }, + "position_ids": { + "shape": [ + 3, + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "edacad438038fb1d85e9097dd2de086c8f14696351353792f13df88e99e9de7b" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 752, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cd572e59171ef52d8e37644cbbdbbf9ff86d77d31cf48b19c4821d7349c026f7" + }, + "position_ids": { + "shape": [ + 3, + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "3d615db0cf3b07f33f32c5d24335f9abdd5b4599e5de79b20326f339520128d1" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 469, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "fecbffc833f744dd32c6b0296b399ef7256ded521c75fd8a5dfb2fd6f5e3c762" + }, + "position_ids": { + "shape": [ + 3, + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "a679452a2039eff05da911d8657b1857f058184d4bb373cd35576f7d3bfca410" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "a075316b24c03cafe09f612e8c4499e0c87035b098bf3db6f8023f7be18c405d" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 460, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0472dbfc0ad390d48f2d4340f8688dfb77298cede625d8d070c3ec3648cd712b" + }, + "position_ids": { + "shape": [ + 3, + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "506ff79aaba73a3bd70f9b1fac38badd9497de8377e2db255b1322b7ae308b86" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cb1f6fae46aaeb1f6b21beafd94e066b87b0bd4a02e7f10bf6f0e991cbc43f49" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.998498797416687, + "cancel": 0.0015011822106316686 + }, + "confidence": 0.9837552323853659 + }, + "q2": { + "type": "choice", + "choice": "cancel", + "probabilities": { + "cancel": 0.9995121955871582, + "save": 0.00048785717808641493 + }, + "confidence": 0.9939293781678539 + }, + "q3": { + "type": "choice", + "choice": "only", + "probabilities": { + "only": 1.0 + }, + "confidence": 1.0 + }, + "q4": { + "type": "choice", + "choice": "option-3", + "probabilities": { + "option-0": 0.07546718418598175, + "option-1": 0.00034948240499943495, + "option-2": 0.263406366109848, + "option-3": 0.557631254196167, + "option-4": 0.009013270027935505, + "option-5": 0.01908109337091446, + "option-6": 0.007019542157649994, + "option-7": 0.016839005053043365, + "option-8": 0.009013270027935505, + "option-9": 0.0025823453906923532, + "option-10": 0.004824455827474594, + "option-11": 0.003315796609967947, + "option-12": 0.002011132426559925, + "option-13": 0.0022789116483181715, + "option-14": 0.00619472423568368, + "option-15": 0.0010764816543087363, + "option-16": 0.0037572900764644146, + "option-17": 0.0006529190577566624, + "option-18": 0.002011132426559925, + "option-19": 0.0012198134791105986, + "option-20": 0.00044874430750496686, + "option-21": 0.0005084939184598625, + "option-22": 0.003315796609967947, + "option-23": 0.0013822298496961594, + "option-24": 0.0017748181708157063, + "option-25": 0.004824455827474594 + }, + "confidence": 0.5755459268738158 + }, + "q5": { + "type": "choice", + "choice": "object", + "probabilities": { + "null": 0.07443060725927353, + "object": 0.9067503809928894, + "array": 0.01881900243461132 + }, + "confidence": 0.6751463333759231 + }, + "q6": { + "type": "choice", + "choice": "first", + "probabilities": { + "first": 0.531209409236908, + "second": 0.4687906503677368 + }, + "confidence": 0.002812297157495758 + }, + "q7": { + "type": "choice", + "choice": "yes", + "probabilities": { + "yes": 0.9823379516601562, + "no": 0.0035428637638688087, + "wait": 0.006618940737098455, + "help": 0.007500242441892624 + }, + "confidence": 0.9225223144825633 + }, + "q8": { + "type": "choice", + "choice": "leave", + "probabilities": { + "stay": 0.01798621006309986, + "leave": 0.9820137619972229 + }, + "confidence": 0.8700206851739604 + } + }, + "usage": { + "input_tokens": 3874, + "output_tokens": 0 + } + } + }, + { + "id": "distinct-jpeg", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 8, + "language": 8, + "image_preprocess": 8 + }, + "reuse_counts": { + "vision": 1, + "language": 8, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "0d717f46abbc57e2696c66d4969fc777e96415a6f67740a7087cf77d78de218d" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "ff71ef4e6c311c56cd3dbe484f8a05773dba0361b21e97745ca7394758319d1c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "eb7ea7dd8487457bc025d44ba5ebc1550026250abea05f847d61b8ea6f52af8e" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "60b6d77d34ada12b8def875237be8cd0feee4475ccf4cb389bd44245b21a8f9d" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "c0e9e08d7a1863b1e91cca10457d593e1281ccd5695cfb89683b8121826cff38" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8de01e028cd92e75ba21cf901916223dc844a7c580f8bb2b943828403cb28198" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "cc047cd8ed2d1ddd4493abd7cff8ee7ba9fcd0b6265e1a1b8b4b2f6c6e822390" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "6fd0e47d02ff77335d5b2733962a9f7a1caed5ea867aa67b8c3b4b788509dba1" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "deb3cc137c72ac7e023b78a4d29d507ddf95f02f2572e38dd068a3574116ac21" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 443, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "a589f8282553e6db720ee42d435325c1b11c97a64cb863905aa14caf666ae9c2" + }, + "position_ids": { + "shape": [ + 3, + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "9e4fd6391bea467b1a278b2506d278b0ae583fc15a686a31882dc377374e04d1" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 442, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "bb28cc0469fe66ba66db8fc5dcc38441e6b19fe179eefe44ca266218ab23158c" + }, + "position_ids": { + "shape": [ + 3, + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "f706ff63624d02735d39ebe7097dc53d833763276475713d80259d5fed6d7446" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 426, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "e2162bdf94dc7edb76358f4a41d47550fdf417315858da8def30e97d09e49dd3" + }, + "position_ids": { + "shape": [ + 3, + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "edacad438038fb1d85e9097dd2de086c8f14696351353792f13df88e99e9de7b" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 752, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "e9b818b64d6deba45993bde264f03a346381ffa6115fd3ff77dd6e5a4f42f66a" + }, + "position_ids": { + "shape": [ + 3, + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "3d615db0cf3b07f33f32c5d24335f9abdd5b4599e5de79b20326f339520128d1" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 469, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "32b8963f7691bc77156406010aefdd906eaf36b32870ae7854b89a2d0744f47d" + }, + "position_ids": { + "shape": [ + 3, + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "a679452a2039eff05da911d8657b1857f058184d4bb373cd35576f7d3bfca410" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "5b8c4b14a06f1caa45fd89cf48f782a118c66a7b12908cdf41ec6963b8335c10" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 460, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "fceb2a3f05e5b84236e9df40a07c54ba71c56544737d4348ce045f6492026039" + }, + "position_ids": { + "shape": [ + 3, + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "506ff79aaba73a3bd70f9b1fac38badd9497de8377e2db255b1322b7ae308b86" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "151e9a9b4df949b7475a5617f97b1201d5bd472639088322ee1d981bf5de3103" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.998498797416687, + "cancel": 0.0015011822106316686 + }, + "confidence": 0.9837552323853659 + }, + "q2": { + "type": "choice", + "choice": "cancel", + "probabilities": { + "cancel": 0.9991958737373352, + "save": 0.0008040859247557819 + }, + "confidence": 0.9905740626396378 + }, + "q3": { + "type": "choice", + "choice": "only", + "probabilities": { + "only": 1.0 + }, + "confidence": 1.0 + }, + "q4": { + "type": "choice", + "choice": "option-3", + "probabilities": { + "option-0": 0.07067349553108215, + "option-1": 0.0002888264134526253, + "option-2": 0.31673663854599, + "option-3": 0.522210419178009, + "option-4": 0.007448931224644184, + "option-5": 0.013916435651481152, + "option-6": 0.006573658902198076, + "option-7": 0.013916435651481152, + "option-8": 0.007448931224644184, + "option-9": 0.002134154550731182, + "option-10": 0.004518005531281233, + "option-11": 0.0031051766127347946, + "option-12": 0.001883384888060391, + "option-13": 0.001883384888060391, + "option-14": 0.006573658902198076, + "option-15": 0.001142330700531602, + "option-16": 0.003987125586718321, + "option-17": 0.0006928585353307426, + "option-18": 0.001883384888060391, + "option-19": 0.001142330700531602, + "option-20": 0.00042023995774798095, + "option-21": 0.00042023995774798095, + "option-22": 0.003987125586718321, + "option-23": 0.001142330700531602, + "option-24": 0.001883384888060391, + "option-25": 0.003987125586718321 + }, + "confidence": 0.5842158243885958 + }, + "q5": { + "type": "choice", + "choice": "null", + "probabilities": { + "null": 0.46689873933792114, + "object": 0.2831884026527405, + "array": 0.24991288781166077 + }, + "confidence": 0.0356628420875128 + }, + "q6": { + "type": "choice", + "choice": "second", + "probabilities": { + "first": 0.3486451506614685, + "second": 0.6513549089431763 + }, + "confidence": 0.06714781287071625 + }, + "q7": { + "type": "choice", + "choice": "yes", + "probabilities": { + "yes": 0.9716947674751282, + "no": 0.009526160545647144, + "wait": 0.006547227967530489, + "help": 0.01223183237016201 + }, + "confidence": 0.8852895522159283 + }, + "q8": { + "type": "choice", + "choice": "leave", + "probabilities": { + "stay": 0.020332353189587593, + "leave": 0.9796676635742188 + }, + "confidence": 0.8566974578024523 + } + }, + "usage": { + "input_tokens": 3874, + "output_tokens": 0 + } + } + }, + { + "id": "distinct-reversed", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 8, + "language": 8, + "image_preprocess": 8 + }, + "reuse_counts": { + "vision": 1, + "language": 8, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "deb3cc137c72ac7e023b78a4d29d507ddf95f02f2572e38dd068a3574116ac21" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "cc047cd8ed2d1ddd4493abd7cff8ee7ba9fcd0b6265e1a1b8b4b2f6c6e822390" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "6fd0e47d02ff77335d5b2733962a9f7a1caed5ea867aa67b8c3b4b788509dba1" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "c0e9e08d7a1863b1e91cca10457d593e1281ccd5695cfb89683b8121826cff38" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8de01e028cd92e75ba21cf901916223dc844a7c580f8bb2b943828403cb28198" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "eb7ea7dd8487457bc025d44ba5ebc1550026250abea05f847d61b8ea6f52af8e" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "60b6d77d34ada12b8def875237be8cd0feee4475ccf4cb389bd44245b21a8f9d" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "0d717f46abbc57e2696c66d4969fc777e96415a6f67740a7087cf77d78de218d" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "ff71ef4e6c311c56cd3dbe484f8a05773dba0361b21e97745ca7394758319d1c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cb1f6fae46aaeb1f6b21beafd94e066b87b0bd4a02e7f10bf6f0e991cbc43f49" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 460, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0472dbfc0ad390d48f2d4340f8688dfb77298cede625d8d070c3ec3648cd712b" + }, + "position_ids": { + "shape": [ + 3, + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "506ff79aaba73a3bd70f9b1fac38badd9497de8377e2db255b1322b7ae308b86" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "a075316b24c03cafe09f612e8c4499e0c87035b098bf3db6f8023f7be18c405d" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 469, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "fecbffc833f744dd32c6b0296b399ef7256ded521c75fd8a5dfb2fd6f5e3c762" + }, + "position_ids": { + "shape": [ + 3, + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "a679452a2039eff05da911d8657b1857f058184d4bb373cd35576f7d3bfca410" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 752, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cd572e59171ef52d8e37644cbbdbbf9ff86d77d31cf48b19c4821d7349c026f7" + }, + "position_ids": { + "shape": [ + 3, + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "3d615db0cf3b07f33f32c5d24335f9abdd5b4599e5de79b20326f339520128d1" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 426, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "b464ff04b79496dcab96f3a8b588a4bc5e611075d4e44ff7b526eaa685658b4a" + }, + "position_ids": { + "shape": [ + 3, + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "edacad438038fb1d85e9097dd2de086c8f14696351353792f13df88e99e9de7b" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 442, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "db88bedddbbd1d2b6aaf63664379d5206b0de9ef3fcf0ccdd0fb951599364847" + }, + "position_ids": { + "shape": [ + 3, + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "f706ff63624d02735d39ebe7097dc53d833763276475713d80259d5fed6d7446" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 443, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "c108e3059ad63ab2efd4d2d194766ab18ef6144819985ff6448dae85f476b032" + }, + "position_ids": { + "shape": [ + 3, + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "9e4fd6391bea467b1a278b2506d278b0ae583fc15a686a31882dc377374e04d1" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q8": { + "type": "choice", + "choice": "leave", + "probabilities": { + "stay": 0.01798621006309986, + "leave": 0.9820137619972229 + }, + "confidence": 0.8700206851739604 + }, + "q7": { + "type": "choice", + "choice": "yes", + "probabilities": { + "yes": 0.9823379516601562, + "no": 0.0035428637638688087, + "wait": 0.006618940737098455, + "help": 0.007500242441892624 + }, + "confidence": 0.9225223144825633 + }, + "q6": { + "type": "choice", + "choice": "first", + "probabilities": { + "first": 0.531209409236908, + "second": 0.4687906503677368 + }, + "confidence": 0.002812297157495758 + }, + "q5": { + "type": "choice", + "choice": "object", + "probabilities": { + "null": 0.07443060725927353, + "object": 0.9067503809928894, + "array": 0.01881900243461132 + }, + "confidence": 0.6751463333759231 + }, + "q4": { + "type": "choice", + "choice": "option-3", + "probabilities": { + "option-0": 0.07546718418598175, + "option-1": 0.00034948240499943495, + "option-2": 0.263406366109848, + "option-3": 0.557631254196167, + "option-4": 0.009013270027935505, + "option-5": 0.01908109337091446, + "option-6": 0.007019542157649994, + "option-7": 0.016839005053043365, + "option-8": 0.009013270027935505, + "option-9": 0.0025823453906923532, + "option-10": 0.004824455827474594, + "option-11": 0.003315796609967947, + "option-12": 0.002011132426559925, + "option-13": 0.0022789116483181715, + "option-14": 0.00619472423568368, + "option-15": 0.0010764816543087363, + "option-16": 0.0037572900764644146, + "option-17": 0.0006529190577566624, + "option-18": 0.002011132426559925, + "option-19": 0.0012198134791105986, + "option-20": 0.00044874430750496686, + "option-21": 0.0005084939184598625, + "option-22": 0.003315796609967947, + "option-23": 0.0013822298496961594, + "option-24": 0.0017748181708157063, + "option-25": 0.004824455827474594 + }, + "confidence": 0.5755459268738158 + }, + "q3": { + "type": "choice", + "choice": "only", + "probabilities": { + "only": 1.0 + }, + "confidence": 1.0 + }, + "q2": { + "type": "choice", + "choice": "cancel", + "probabilities": { + "cancel": 0.9995121955871582, + "save": 0.00048785717808641493 + }, + "confidence": 0.9939293781678539 + }, + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.998498797416687, + "cancel": 0.0015011822106316686 + }, + "confidence": 0.9837552323853659 + } + }, + "usage": { + "input_tokens": 3874, + "output_tokens": 0 + } + } + }, + { + "id": "distinct-small-image", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 8, + "language": 8, + "image_preprocess": 8 + }, + "reuse_counts": { + "vision": 1, + "language": 8, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 223 + ], + "dtype": "torch.int64", + "sha256": "9d7231a5a328a6cd012a665bedf8b65524e30d729aa2871f4f9d7d8d6b9cd99d" + }, + "attention_mask": { + "shape": [ + 1, + 223 + ], + "dtype": "torch.int64", + "sha256": "37f69a92ed5107c51231eb10a952d103922d8737a5ef14678508b68c6a0beabe" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 223 + ], + "dtype": "torch.int64", + "sha256": "1e0ebc653eddfe88d9b9399061a632e9741008379b0bc9bb21f2d825c84a2ac2" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 222 + ], + "dtype": "torch.int64", + "sha256": "3953aac266172f9ee29c3cdc862a4c1e6831cb30240cf5b1824a2b31757d0fb5" + }, + "attention_mask": { + "shape": [ + 1, + 222 + ], + "dtype": "torch.int64", + "sha256": "c301bfbcb26c5293c6f1688ca3df34437ba6d32cc807b1d5bd6d0b4bdf8ca3ba" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 222 + ], + "dtype": "torch.int64", + "sha256": "94fac1acc4e527d6c414b62ca2c6c440be1c4a37810ddcbf7014938b2b2461f3" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 206 + ], + "dtype": "torch.int64", + "sha256": "feed65e7bcc5bda2a74af03514af5376d988fbb50ca53dd338e0b9e52efee57e" + }, + "attention_mask": { + "shape": [ + 1, + 206 + ], + "dtype": "torch.int64", + "sha256": "030a7d06a97c8b65c7e8da52911bf7aea1d2ca41a430efdec0e761c35ecb1e87" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 206 + ], + "dtype": "torch.int64", + "sha256": "61d5f846b6c4f6638e29a11024c6574e6d20ec905a7beabc225d5d2dda739e4c" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 532 + ], + "dtype": "torch.int64", + "sha256": "bac1ece493846e52ef6ddc33ccab1954bab98d9fe1472be3e082d8e1b92c0fd1" + }, + "attention_mask": { + "shape": [ + 1, + 532 + ], + "dtype": "torch.int64", + "sha256": "45f71924adcefcfa5208a0224cb17f075f80f4e256eded175a42783fbb38be09" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 532 + ], + "dtype": "torch.int64", + "sha256": "77598fb85ff6712e7e4a3f7e8dbdb4ff1f289f17cd0f8b4bfd0ce20f8a9a2c20" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 249 + ], + "dtype": "torch.int64", + "sha256": "616f3a69d07c5bf9b5d9264efb0c0205c19aee13849e19225817659584ea62ae" + }, + "attention_mask": { + "shape": [ + 1, + 249 + ], + "dtype": "torch.int64", + "sha256": "5772cc13dfa52a6436735810cb716e07c836d807b5bedd759987c17ae4d83e1b" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 249 + ], + "dtype": "torch.int64", + "sha256": "cb0537d81f5c85e6a2ae3a7a6891e9a09564f4be2eb5e05be362fc0075d2cec1" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "8f822829d3790bd753a4321d2aa9381615fd2db65cf613a72ad551aa0cf67ab5" + }, + "attention_mask": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "17f64dedf022d9f1c7bb515e639804af287f302776401979221a1aa146a2ca92" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "14e7e638809cb581b6591752a143d6f3420807408f17b67202b40e9b408c4963" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 240 + ], + "dtype": "torch.int64", + "sha256": "fc53d3218c5edc7db677a8d8f812139a6381064ae9a4a510a7b4ecbd37cb58f0" + }, + "attention_mask": { + "shape": [ + 1, + 240 + ], + "dtype": "torch.int64", + "sha256": "e4eaaa8d2ab4d56a946886f95e7fa6865cb411a3e34985d6651eb35c4e0eff0d" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 240 + ], + "dtype": "torch.int64", + "sha256": "71e9ca6442dc33ff58c57959f7f0f61aa6ef1e9c2fee04f9af98824bacd449ae" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "a287f00ea6301930d67b9827a5d8b9732643300a838e1e8e42f6a6d9d2212a41" + }, + "attention_mask": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "17f64dedf022d9f1c7bb515e639804af287f302776401979221a1aa146a2ca92" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "14e7e638809cb581b6591752a143d6f3420807408f17b67202b40e9b408c4963" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 223, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "a7518273b9a87818edea8021f6210434d4dcd43cb0a31040d93e402ed8e4327d" + }, + "position_ids": { + "shape": [ + 3, + 1, + 223 + ], + "dtype": "torch.int64", + "sha256": "4acc9b9832ab208fb2f6236c91f3fa9a9888c0c60299e9633f5906c703e5dbf3" + }, + "attention_mask": { + "shape": [ + 1, + 223 + ], + "dtype": "torch.int64", + "sha256": "37f69a92ed5107c51231eb10a952d103922d8737a5ef14678508b68c6a0beabe" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 222, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "505ee754d85f0c2f50dedb849324b790b573ac4d3796a29399af909e4a535264" + }, + "position_ids": { + "shape": [ + 3, + 1, + 222 + ], + "dtype": "torch.int64", + "sha256": "d508e8173eddb4367dcff2e034b9e660da9468ecfa127f974a9f24937cdd8308" + }, + "attention_mask": { + "shape": [ + 1, + 222 + ], + "dtype": "torch.int64", + "sha256": "c301bfbcb26c5293c6f1688ca3df34437ba6d32cc807b1d5bd6d0b4bdf8ca3ba" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 206, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "f9f37805b6e53077164e2bb8a0706c2177d8afa32dec2c2202720aa44127aa30" + }, + "position_ids": { + "shape": [ + 3, + 1, + 206 + ], + "dtype": "torch.int64", + "sha256": "9da5fa04c7cac86c61d6009005d7d5baf8ecd59dde2c91510aa53f770377dd37" + }, + "attention_mask": { + "shape": [ + 1, + 206 + ], + "dtype": "torch.int64", + "sha256": "030a7d06a97c8b65c7e8da52911bf7aea1d2ca41a430efdec0e761c35ecb1e87" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 532, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "81669f0ce1bcc6736decc0a87f3dbc1c7b2cf79a77208406a82b18cf3d0afe0c" + }, + "position_ids": { + "shape": [ + 3, + 1, + 532 + ], + "dtype": "torch.int64", + "sha256": "abb8b32ebad69693806dc6ec043b8b3cb88fd452fef624179bbdd084fd6f9420" + }, + "attention_mask": { + "shape": [ + 1, + 532 + ], + "dtype": "torch.int64", + "sha256": "45f71924adcefcfa5208a0224cb17f075f80f4e256eded175a42783fbb38be09" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 249, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "13b2aed945654c35c370e960c9acc2b4388f064fac347b19b0e2cebdea1ee4a5" + }, + "position_ids": { + "shape": [ + 3, + 1, + 249 + ], + "dtype": "torch.int64", + "sha256": "b0039549be2532f6971c4b58be875cd190cee0ed7c09fe187c51e8aab94c045a" + }, + "attention_mask": { + "shape": [ + 1, + 249 + ], + "dtype": "torch.int64", + "sha256": "5772cc13dfa52a6436735810cb716e07c836d807b5bedd759987c17ae4d83e1b" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 221, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "1c27841fdfad3529853fe147f72a5728b936284b6c2f5df403856af9312e6182" + }, + "position_ids": { + "shape": [ + 3, + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "2a2d4966fa57bf1b9d34ad6ce5b06e03bf2a085bc134d66da2509b95730be49e" + }, + "attention_mask": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "17f64dedf022d9f1c7bb515e639804af287f302776401979221a1aa146a2ca92" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 240, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "2aa99bf2579a64e805fb0dc9952b4f70f00f04f46c9768b6f3138fe44080382b" + }, + "position_ids": { + "shape": [ + 3, + 1, + 240 + ], + "dtype": "torch.int64", + "sha256": "93e979c91a7902ba7378c79c62473a4749b7f7542abd12b1a010733217c90a93" + }, + "attention_mask": { + "shape": [ + 1, + 240 + ], + "dtype": "torch.int64", + "sha256": "e4eaaa8d2ab4d56a946886f95e7fa6865cb411a3e34985d6651eb35c4e0eff0d" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 221, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "d8c5640ae7f95fc64b7920656cd3465c4cbf22a5ed617cb886a71345a35470d8" + }, + "position_ids": { + "shape": [ + 3, + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "2a2d4966fa57bf1b9d34ad6ce5b06e03bf2a085bc134d66da2509b95730be49e" + }, + "attention_mask": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "17f64dedf022d9f1c7bb515e639804af287f302776401979221a1aa146a2ca92" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9978172779083252, + "cancel": 0.002182716503739357 + }, + "confidence": 0.9775599661366724 + }, + "q2": { + "type": "choice", + "choice": "cancel", + "probabilities": { + "cancel": 0.9990890026092529, + "save": 0.0009110512328334153 + }, + "confidence": 0.9894845258048839 + }, + "q3": { + "type": "choice", + "choice": "only", + "probabilities": { + "only": 1.0 + }, + "confidence": 1.0 + }, + "q4": { + "type": "choice", + "choice": "option-2", + "probabilities": { + "option-0": 0.06260567903518677, + "option-1": 0.0002899218525271863, + "option-2": 0.5939862132072449, + "option-3": 0.24761027097702026, + "option-4": 0.009600892663002014, + "option-5": 0.015829196199774742, + "option-6": 0.00659859087318182, + "option-7": 0.015829196199774742, + "option-8": 0.007477182894945145, + "option-9": 0.0016683851135894656, + "option-10": 0.003116953419521451, + "option-11": 0.0035319707822054625, + "option-12": 0.0024274857714772224, + "option-13": 0.0024274857714772224, + "option-14": 0.007477182894945145, + "option-15": 0.001011926680803299, + "option-16": 0.0024274857714772224, + "option-17": 0.0007880892371758819, + "option-18": 0.001890527899377048, + "option-19": 0.001472344622015953, + "option-20": 0.00042183377081528306, + "option-21": 0.000541645276825875, + "option-22": 0.004535140469670296, + "option-23": 0.001011926680803299, + "option-24": 0.001890527899377048, + "option-25": 0.0035319707822054625 + }, + "confidence": 0.5978649242508383 + }, + "q5": { + "type": "choice", + "choice": "object", + "probabilities": { + "null": 0.0662643164396286, + "object": 0.9147506356239319, + "array": 0.018985042348504066 + }, + "confidence": 0.6936001429109977 + }, + "q6": { + "type": "choice", + "choice": "second", + "probabilities": { + "first": 0.3775406777858734, + "second": 0.622459352016449 + }, + "confidence": 0.04371347674840487 + }, + "q7": { + "type": "choice", + "choice": "yes", + "probabilities": { + "yes": 0.9805492758750916, + "no": 0.004007280804216862, + "wait": 0.0058305589482188225, + "help": 0.009612967260181904 + }, + "confidence": 0.9163063661161868 + }, + "q8": { + "type": "choice", + "choice": "leave", + "probabilities": { + "stay": 0.01243165135383606, + "leave": 0.9875683188438416 + }, + "confidence": 0.9034864798488087 + } + }, + "usage": { + "input_tokens": 2114, + "output_tokens": 0 + } + } + }, + { + "id": "distinct-original-again", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 8, + "language": 8, + "image_preprocess": 8 + }, + "reuse_counts": { + "vision": 1, + "language": 8, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "0d717f46abbc57e2696c66d4969fc777e96415a6f67740a7087cf77d78de218d" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "ff71ef4e6c311c56cd3dbe484f8a05773dba0361b21e97745ca7394758319d1c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "eb7ea7dd8487457bc025d44ba5ebc1550026250abea05f847d61b8ea6f52af8e" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "60b6d77d34ada12b8def875237be8cd0feee4475ccf4cb389bd44245b21a8f9d" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "c0e9e08d7a1863b1e91cca10457d593e1281ccd5695cfb89683b8121826cff38" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8de01e028cd92e75ba21cf901916223dc844a7c580f8bb2b943828403cb28198" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "cc047cd8ed2d1ddd4493abd7cff8ee7ba9fcd0b6265e1a1b8b4b2f6c6e822390" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "6fd0e47d02ff77335d5b2733962a9f7a1caed5ea867aa67b8c3b4b788509dba1" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "deb3cc137c72ac7e023b78a4d29d507ddf95f02f2572e38dd068a3574116ac21" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 443, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "c108e3059ad63ab2efd4d2d194766ab18ef6144819985ff6448dae85f476b032" + }, + "position_ids": { + "shape": [ + 3, + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "9e4fd6391bea467b1a278b2506d278b0ae583fc15a686a31882dc377374e04d1" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 442, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "db88bedddbbd1d2b6aaf63664379d5206b0de9ef3fcf0ccdd0fb951599364847" + }, + "position_ids": { + "shape": [ + 3, + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "f706ff63624d02735d39ebe7097dc53d833763276475713d80259d5fed6d7446" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 426, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "b464ff04b79496dcab96f3a8b588a4bc5e611075d4e44ff7b526eaa685658b4a" + }, + "position_ids": { + "shape": [ + 3, + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "edacad438038fb1d85e9097dd2de086c8f14696351353792f13df88e99e9de7b" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 752, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cd572e59171ef52d8e37644cbbdbbf9ff86d77d31cf48b19c4821d7349c026f7" + }, + "position_ids": { + "shape": [ + 3, + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "3d615db0cf3b07f33f32c5d24335f9abdd5b4599e5de79b20326f339520128d1" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 469, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "fecbffc833f744dd32c6b0296b399ef7256ded521c75fd8a5dfb2fd6f5e3c762" + }, + "position_ids": { + "shape": [ + 3, + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "a679452a2039eff05da911d8657b1857f058184d4bb373cd35576f7d3bfca410" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "a075316b24c03cafe09f612e8c4499e0c87035b098bf3db6f8023f7be18c405d" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 460, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0472dbfc0ad390d48f2d4340f8688dfb77298cede625d8d070c3ec3648cd712b" + }, + "position_ids": { + "shape": [ + 3, + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "506ff79aaba73a3bd70f9b1fac38badd9497de8377e2db255b1322b7ae308b86" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cb1f6fae46aaeb1f6b21beafd94e066b87b0bd4a02e7f10bf6f0e991cbc43f49" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.998498797416687, + "cancel": 0.0015011822106316686 + }, + "confidence": 0.9837552323853659 + }, + "q2": { + "type": "choice", + "choice": "cancel", + "probabilities": { + "cancel": 0.9995121955871582, + "save": 0.00048785717808641493 + }, + "confidence": 0.9939293781678539 + }, + "q3": { + "type": "choice", + "choice": "only", + "probabilities": { + "only": 1.0 + }, + "confidence": 1.0 + }, + "q4": { + "type": "choice", + "choice": "option-3", + "probabilities": { + "option-0": 0.07546718418598175, + "option-1": 0.00034948240499943495, + "option-2": 0.263406366109848, + "option-3": 0.557631254196167, + "option-4": 0.009013270027935505, + "option-5": 0.01908109337091446, + "option-6": 0.007019542157649994, + "option-7": 0.016839005053043365, + "option-8": 0.009013270027935505, + "option-9": 0.0025823453906923532, + "option-10": 0.004824455827474594, + "option-11": 0.003315796609967947, + "option-12": 0.002011132426559925, + "option-13": 0.0022789116483181715, + "option-14": 0.00619472423568368, + "option-15": 0.0010764816543087363, + "option-16": 0.0037572900764644146, + "option-17": 0.0006529190577566624, + "option-18": 0.002011132426559925, + "option-19": 0.0012198134791105986, + "option-20": 0.00044874430750496686, + "option-21": 0.0005084939184598625, + "option-22": 0.003315796609967947, + "option-23": 0.0013822298496961594, + "option-24": 0.0017748181708157063, + "option-25": 0.004824455827474594 + }, + "confidence": 0.5755459268738158 + }, + "q5": { + "type": "choice", + "choice": "object", + "probabilities": { + "null": 0.07443060725927353, + "object": 0.9067503809928894, + "array": 0.01881900243461132 + }, + "confidence": 0.6751463333759231 + }, + "q6": { + "type": "choice", + "choice": "first", + "probabilities": { + "first": 0.531209409236908, + "second": 0.4687906503677368 + }, + "confidence": 0.002812297157495758 + }, + "q7": { + "type": "choice", + "choice": "yes", + "probabilities": { + "yes": 0.9823379516601562, + "no": 0.0035428637638688087, + "wait": 0.006618940737098455, + "help": 0.007500242441892624 + }, + "confidence": 0.9225223144825633 + }, + "q8": { + "type": "choice", + "choice": "leave", + "probabilities": { + "stay": 0.01798621006309986, + "leave": 0.9820137619972229 + }, + "confidence": 0.8700206851739604 + } + }, + "usage": { + "input_tokens": 3874, + "output_tokens": 0 + } + } + } + ], + "cases": [ + { + "id": "320x240-long-q4", + "size": [ + 320, + 240 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 4, + "status": "complete", + "fixture_sha256": "a549e1d703911d836fadbf343204ccf8b92a1f3bf244e4e9ee3507eb876b0d08", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 4, + "language": 4, + "image_preprocess": 4 + }, + "reuse_counts": { + "vision": 1, + "language": 4, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 614, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "7dcdd73c6c7ed152963408f5d27174d01a49402bb537d819a68d59588a53984e" + }, + "position_ids": { + "shape": [ + 3, + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "8a75647b9a14785031d9b56d339545518f2603ae1b16f65e959f3d953d61ef68" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 614, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "7dcdd73c6c7ed152963408f5d27174d01a49402bb537d819a68d59588a53984e" + }, + "position_ids": { + "shape": [ + 3, + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "8a75647b9a14785031d9b56d339545518f2603ae1b16f65e959f3d953d61ef68" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 614, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "7dcdd73c6c7ed152963408f5d27174d01a49402bb537d819a68d59588a53984e" + }, + "position_ids": { + "shape": [ + 3, + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "8a75647b9a14785031d9b56d339545518f2603ae1b16f65e959f3d953d61ef68" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 614, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "7dcdd73c6c7ed152963408f5d27174d01a49402bb537d819a68d59588a53984e" + }, + "position_ids": { + "shape": [ + 3, + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "8a75647b9a14785031d9b56d339545518f2603ae1b16f65e959f3d953d61ef68" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9926069974899292, + "cancel": 0.0007049240521155298, + "wait": 0.006688133347779512 + }, + "confidence": 0.9581546345308546 + }, + "q2": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9926069974899292, + "cancel": 0.0007049240521155298, + "wait": 0.006688133347779512 + }, + "confidence": 0.9581546345308546 + }, + "q3": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9926069974899292, + "cancel": 0.0007049240521155298, + "wait": 0.006688133347779512 + }, + "confidence": 0.9581546345308546 + }, + "q4": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9926069974899292, + "cancel": 0.0007049240521155298, + "wait": 0.006688133347779512 + }, + "confidence": 0.9581546345308546 + } + }, + "usage": { + "input_tokens": 2456, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 575.1979751512408, + 564.6542515605688, + 571.3232504203916, + 558.1319211050868, + 575.1024214550853, + 566.9957073405385, + 569.6713980287313, + 575.48363879323, + 568.5408757999539, + 557.0428688079119, + 555.636896751821, + 552.8752896934748, + 563.8765869662166, + 565.0777379050851, + 563.865595497191, + 550.3153009340167, + 630.2372822538018, + 576.7403934150934, + 563.5982034727931, + 564.8808404803276, + 568.8018593937159, + 579.4807197526097, + 577.2860944271088, + 564.6435562521219, + 573.7875392660499, + 563.6786967515945, + 570.323652587831, + 567.945409566164, + 571.32479082793, + 558.040227741003, + 559.6551671624184, + 570.5638779327273, + 627.5276076048613, + 571.0512874647975, + 559.811838902533, + 568.4726256877184, + 571.306737139821, + 564.0995549038053, + 578.8942901417613, + 576.6991768032312, + 563.3354876190424, + 573.8525437191129, + 568.1100785732269, + 547.3184501752257, + 539.6996084600687, + 543.6784029006958, + 536.3490311428905, + 536.2363792955875, + 542.8061857819557, + 539.1932846978307 + ], + "p50_ms": 566.0367226228118, + "p95_ms": 579.4807197526097, + "requests_per_second_serial": 1.7665832866196565, + "peak_allocated_bytes": 9589741056, + "peak_reserved_bytes": 10152312832 + }, + "reuse": { + "latencies_ms": [ + 496.86571303755045, + 504.6318396925926, + 499.36859030276537, + 507.25448969751596, + 522.5319843739271, + 538.9944380149245, + 492.1280164271593, + 500.4457412287593, + 498.26749600470066, + 546.6471696272492, + 503.4658908843994, + 501.8788883462548, + 508.5476879030466, + 504.27134707570076, + 495.70270255208015, + 504.5066410675645, + 528.042140416801, + 497.5458988919854, + 498.41294158250093, + 506.49652257561684, + 488.69972210377455, + 504.9344478175044, + 501.89946684986353, + 499.09482058137655, + 504.71614487469196, + 511.97661086916924, + 502.8819106519222, + 516.0193210467696, + 496.92823085933924, + 515.1674225926399, + 503.1533343717456, + 543.9533283933997, + 503.6019906401634, + 516.7973004281521, + 502.25722324103117, + 507.9926010221243, + 507.7830497175455, + 507.11891893297434, + 499.5620772242546, + 506.65976107120514, + 507.2082094848156, + 513.3539270609617, + 488.2128043100238, + 478.0257921665907, + 477.40687523037195, + 478.18479035049677, + 475.56233406066895, + 475.2758862450719, + 474.8974498361349, + 475.74828565120697 + ], + "p50_ms": 503.3096126280725, + "p95_ms": 538.9944380149245, + "requests_per_second_serial": 1.9887769199737115, + "peak_allocated_bytes": 9580157440, + "peak_reserved_bytes": 10152312832 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 539.9410258978605, + 541.9928748160601, + 540.9493464976549, + 540.2805730700493, + 559.1847142204642, + 544.8806742206216, + 553.5480109974742, + 547.376093454659, + 543.8488032668829, + 539.9408992379904, + 543.4069726616144, + 539.9651722982526, + 537.4881783500314, + 542.1803910285234, + 536.6506613790989, + 554.5292096212506, + 540.16965162009, + 543.3424189686775, + 540.1968946680427, + 544.3446561694145, + 538.7122025713325, + 556.9736333563924, + 538.5460630059242, + 562.6097405329347, + 537.6278553158045, + 538.1026910617948, + 537.6214664429426, + 536.0828367993236, + 536.920016631484, + 537.2582850977778, + 547.0552733168006, + 540.7326649874449, + 543.7447922304273, + 537.5046785920858, + 545.3671012073755, + 539.3566619604826, + 550.0415852293372, + 572.9175787419081, + 546.1559351533651, + 564.6410528570414, + 538.3704416453838, + 543.8815811648965, + 537.6983406022191, + 543.1680167093873, + 537.0835829526186, + 550.3275729715824, + 538.122977130115, + 537.9713950678706, + 540.7187128439546, + 538.1477614864707 + ], + "p50_ms": 540.7256889156997, + "p95_ms": 562.6097405329347, + "requests_per_second_serial": 1.8390683028023957, + "peak_allocated_bytes": 9589741056, + "peak_reserved_bytes": 10152312832 + }, + "reuse": { + "latencies_ms": [ + 497.93149810284376, + 479.783371090889, + 487.2375698760152, + 478.42712700366974, + 483.93490817397833, + 492.2564383596182, + 500.6401678547263, + 503.8292892277241, + 486.29689682275057, + 475.96478927880526, + 475.888573564589, + 476.9058786332607, + 476.2086970731616, + 475.2753423526883, + 475.37383530288935, + 475.47623328864574, + 476.7852835357189, + 477.45491191744804, + 480.0272220745683, + 485.1318262517452, + 483.1821611151099, + 549.3687111884356, + 488.68654016405344, + 495.29649782925844, + 477.1548304706812, + 475.95350444316864, + 483.2375589758158, + 474.30081851780415, + 482.4952529743314, + 476.1641025543213, + 490.3132412582636, + 474.6654247865081, + 475.3603236749768, + 476.2497069314122, + 480.23151978850365, + 486.0460674390197, + 479.0262244641781, + 487.8355925902724, + 477.5784518569708, + 476.9646469503641, + 476.4432078227401, + 475.4300732165575, + 476.0587802156806, + 475.4308657720685, + 475.72710551321507, + 487.79731802642345, + 477.61400137096643, + 481.8195989355445, + 477.56853699684143, + 484.4842376187444 + ], + "p50_ms": 478.0205641873181, + "p95_ms": 500.6401678547263, + "requests_per_second_serial": 2.071309831715888, + "peak_allocated_bytes": 9580157440, + "peak_reserved_bytes": 10152312832 + } + } + ] + }, + { + "id": "320x240-short-q4", + "size": [ + 320, + 240 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 4, + "status": "complete", + "fixture_sha256": "04eb22230f593687092c503492c4f08a40842fac14cd51728cef51980f1078ef", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 4, + "language": 4, + "image_preprocess": 4 + }, + "reuse_counts": { + "vision": 1, + "language": 4, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q2": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q3": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q4": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + } + }, + "usage": { + "input_tokens": 944, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 447.9427170008421, + 439.11196384578943, + 432.72512312978506, + 433.1757687032223, + 429.92130294442177, + 434.27606392651796, + 431.7587111145258, + 432.3846809566021, + 431.03213142603636, + 435.9160531312227, + 432.9937444999814, + 430.91780599206686, + 430.6856570765376, + 431.0530824586749, + 430.8196781203151, + 435.00662688165903, + 430.602059699595, + 449.2915505543351, + 464.2766145989299, + 449.3098761886358, + 446.353480219841, + 446.76885288208723, + 451.6007313504815, + 460.37872321903706, + 453.9673635736108, + 451.1540252715349, + 461.8903789669275, + 446.9074681401253, + 455.1829667761922, + 444.49592009186745, + 457.7379086986184, + 475.13841185718775, + 452.47098710387945, + 457.5165109708905, + 449.4000440463424, + 449.51500929892063, + 445.77423855662346, + 452.2468438372016, + 445.88162936270237, + 460.30969358980656, + 448.66712111979723, + 448.47389310598373, + 464.9360151961446, + 458.8745515793562, + 458.3305837586522, + 453.614916652441, + 452.8989056125283, + 458.0026753246784, + 449.0381069481373, + 456.95266127586365 + ], + "p50_ms": 448.85261403396726, + "p95_ms": 464.2766145989299, + "requests_per_second_serial": 2.2373685279272855, + "peak_allocated_bytes": 9377731072, + "peak_reserved_bytes": 10152312832 + }, + "reuse": { + "latencies_ms": [ + 371.6124212369323, + 369.76676248013973, + 369.17106062173843, + 369.46339532732964, + 379.565323702991, + 373.23246244341135, + 371.1720071732998, + 373.03572427481413, + 368.086907081306, + 367.64207668602467, + 368.5831828042865, + 367.8721934556961, + 370.6586239859462, + 368.5129852965474, + 368.20843163877726, + 367.29587335139513, + 367.0774148777127, + 374.5633363723755, + 386.7047894746065, + 382.5996723026037, + 386.9540197774768, + 370.90781424194574, + 389.974158257246, + 381.9216247648001, + 385.1577481254935, + 385.24582609534264, + 388.83524015545845, + 380.7246210053563, + 386.22334972023964, + 378.35328932851553, + 385.37488505244255, + 392.1938128769398, + 383.2859368994832, + 382.66915921121836, + 382.6449625194073, + 391.42472203820944, + 415.47968704253435, + 384.50288213789463, + 390.2891278266907, + 385.3534609079361, + 389.18385189026594, + 385.1093230769038, + 378.57143487781286, + 390.4714975506067, + 405.36888409405947, + 389.0844713896513, + 392.14063435792923, + 382.58589617908, + 390.2287380769849, + 395.0590332970023 + ], + "p50_ms": 382.6223174110055, + "p95_ms": 395.0590332970023, + "requests_per_second_serial": 2.6232749377808733, + "peak_allocated_bytes": 9369593344, + "peak_reserved_bytes": 10152312832 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 444.2049777135253, + 443.504941649735, + 468.00733637064695, + 452.47175823897123, + 457.9552048817277, + 470.90562619268894, + 451.6880977898836, + 450.96740778535604, + 451.4036690816283, + 459.67874862253666, + 477.6900867000222, + 462.4739531427622, + 472.1499439328909, + 451.30903739482164, + 460.731846280396, + 449.72977973520756, + 451.41945220530033, + 459.8852591589093, + 466.894319280982, + 449.38125740736723, + 449.9443555250764, + 436.53029948472977, + 455.7104427367449, + 457.0490149781108, + 448.17338790744543, + 433.7569773197174, + 435.7223976403475, + 431.6004263237119, + 433.83114226162434, + 442.6529975607991, + 434.1740682721138, + 436.10846623778343, + 435.9268816187978, + 432.0312412455678, + 438.03309090435505, + 434.78921335190535, + 432.6675599440932, + 453.1457098200917, + 429.5369107276201, + 429.12711296230555, + 430.4270977154374, + 443.636623211205, + 433.1041947007179, + 429.65951934456825, + 430.392068810761, + 429.7596802935004, + 430.5161749944091, + 434.0406460687518, + 432.30737652629614, + 430.8033771812916 + ], + "p50_ms": 443.57078243047, + "p95_ms": 470.90562619268894, + "requests_per_second_serial": 2.2464225671969182, + "peak_allocated_bytes": 9377731072, + "peak_reserved_bytes": 10152312832 + }, + "reuse": { + "latencies_ms": [ + 379.81367763131857, + 378.27515695244074, + 388.04083596915007, + 389.61347192525864, + 386.34841050952673, + 387.2940642759204, + 386.74015179276466, + 389.6371591836214, + 394.91057209670544, + 384.1095585376024, + 389.46265634149313, + 395.29598131775856, + 391.40752516686916, + 387.7277746796608, + 387.73139752447605, + 401.93530544638634, + 380.1227109506726, + 381.1776442453265, + 391.61863923072815, + 392.6058216020465, + 394.60490364581347, + 372.49360606074333, + 383.7609104812145, + 391.78399462252855, + 385.4653565213084, + 369.9350757524371, + 370.6429088488221, + 370.25017011910677, + 369.97819785028696, + 369.98492386192083, + 370.3479776158929, + 384.6616465598345, + 370.1544962823391, + 367.41614900529385, + 369.5649253204465, + 370.18561735749245, + 370.09498476982117, + 370.3061090782285, + 369.02522668242455, + 373.3238922432065, + 383.7995817884803, + 372.0416221767664, + 369.7304977104068, + 368.0265825241804, + 379.69921063631773, + 378.38718947023153, + 370.9741588681936, + 369.3692069500685, + 374.90285467356443, + 368.5376327484846 + ], + "p50_ms": 379.75644413381815, + "p95_ms": 394.91057209670544, + "requests_per_second_serial": 2.6325047403167106, + "peak_allocated_bytes": 9369593344, + "peak_reserved_bytes": 10152312832 + } + } + ] + }, + { + "id": "640x480-long-q2", + "size": [ + 640, + 480 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 2, + "status": "complete", + "fixture_sha256": "ad7b074fad40228c57397f495d4f002c98f0163e66037f6c4dfefebdf2bec3cd", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 2, + "language": 2, + "image_preprocess": 2 + }, + "reuse_counts": { + "vision": 1, + "language": 2, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 834, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0f4933b9cd8920b9f60b0202f44a126bf595fcb1618c173f630cb6d23d49a0c6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "290e2e206a836ca5c2d731a28a73a88ddf11e4b46f3bb9df108c6761c783ef08" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 834, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0f4933b9cd8920b9f60b0202f44a126bf595fcb1618c173f630cb6d23d49a0c6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "290e2e206a836ca5c2d731a28a73a88ddf11e4b46f3bb9df108c6761c783ef08" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9877169728279114, + "cancel": 0.0013104835525155067, + "wait": 0.010972544550895691 + }, + "confidence": 0.9359032375170542 + }, + "q2": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9877169728279114, + "cancel": 0.0013104835525155067, + "wait": 0.010972544550895691 + }, + "confidence": 0.9359032375170542 + } + }, + "usage": { + "input_tokens": 1668, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 306.31554313004017, + 306.7330690100789, + 307.01187904924154, + 306.90516252070665, + 306.57154973596334, + 306.61396216601133, + 311.36520486325026, + 308.16455092281103, + 307.10911843925714, + 325.378755107522, + 333.4564659744501, + 309.16539672762156, + 316.7721852660179, + 322.6887509226799, + 310.3355234488845, + 309.490704908967, + 308.4176331758499, + 308.9023809880018, + 308.41214675456285, + 311.52838561683893, + 310.23852713406086, + 309.3226384371519, + 309.09406673163176, + 309.74203161895275, + 309.3407219275832, + 309.5104731619358, + 308.50652884691954, + 308.7864015251398, + 308.871497400105, + 309.0087939053774, + 309.09291096031666, + 310.9085178002715, + 324.39507357776165, + 315.1908777654171, + 309.6751756966114, + 324.73734859377146, + 320.4159876331687, + 308.4790362045169, + 307.78829101473093, + 328.1360073015094, + 312.1350621804595, + 307.4809042736888, + 307.5614245608449, + 308.7014136835933, + 307.78639297932386, + 307.45546612888575, + 307.8983211889863, + 311.1902344971895, + 310.816265642643, + 311.43057346343994 + ], + "p50_ms": 309.12973172962666, + "p95_ms": 325.378755107522, + "requests_per_second_serial": 3.2102655901549055, + "peak_allocated_bytes": 9709360640, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 284.71659403294325, + 284.8666189238429, + 292.71060321480036, + 285.54800245910883, + 284.79478787630796, + 284.85163021832705, + 285.51716916263103, + 293.13087183982134, + 287.79991157352924, + 291.58212430775166, + 288.4122412651777, + 286.67917288839817, + 295.56526336818933, + 294.8282705619931, + 286.78068052977324, + 286.74970753490925, + 286.37575078755617, + 287.6192918047309, + 286.4285772666335, + 286.4792179316282, + 287.5996381044388, + 294.36423163861036, + 286.7814637720585, + 286.9530627503991, + 292.5545237958431, + 288.9631371945143, + 286.4077538251877, + 286.9820185005665, + 292.64513961970806, + 286.75982914865017, + 286.8817914277315, + 286.7006119340658, + 287.0233468711376, + 286.64801362901926, + 287.22291626036167, + 291.76267329603434, + 298.68729785084724, + 298.01653511822224, + 285.9367309138179, + 301.333611831069, + 286.4394932985306, + 286.04850079864264, + 285.86416970938444, + 296.7741070315242, + 285.92984564602375, + 285.6054650619626, + 289.4386425614357, + 292.1271016821265, + 289.20766804367304, + 287.65643388032913 + ], + "p50_ms": 286.9675406254828, + "p95_ms": 298.01653511822224, + "requests_per_second_serial": 3.460985497630654, + "peak_allocated_bytes": 9699164160, + "peak_reserved_bytes": 10567548928 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 311.8111537769437, + 310.5182955041528, + 309.49532706290483, + 309.361825697124, + 314.7874241694808, + 310.39681006222963, + 310.5518417432904, + 310.16609724611044, + 309.8265053704381, + 309.6729489043355, + 316.81726314127445, + 309.6639970317483, + 320.47224696725607, + 318.9687831327319, + 310.4117475450039, + 314.78908006101847, + 317.83068366348743, + 310.71759201586246, + 324.4320098310709, + 309.41671691834927, + 309.0714318677783, + 309.1099997982383, + 319.8853312060237, + 309.87008661031723, + 309.1857796534896, + 309.3026475980878, + 309.6045143902302, + 308.9445782825351, + 310.71196869015694, + 309.19615272432566, + 311.64352502673864, + 309.3316676095128, + 309.58324670791626, + 315.73866680264473, + 309.2490006238222, + 309.2049090191722, + 308.3540955558419, + 312.4467944726348, + 308.79234336316586, + 308.4553238004446, + 326.51976123452187, + 331.4095502719283, + 315.02135563641787, + 320.31380385160446, + 330.0976697355509, + 320.7151126116514, + 321.8344394117594, + 327.6368360966444, + 330.1330879330635, + 318.6745494604111 + ], + "p50_ms": 310.5350686237216, + "p95_ms": 330.0976697355509, + "requests_per_second_serial": 3.1826564918241202, + "peak_allocated_bytes": 9709360640, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 291.2878133356571, + 288.3851081132889, + 287.13994938880205, + 287.5623209401965, + 291.28579422831535, + 287.4359805136919, + 287.24534437060356, + 287.756759673357, + 293.4669367969036, + 288.03638368844986, + 287.27185167372227, + 291.01695120334625, + 290.2847258374095, + 302.7508966624737, + 294.5482460781932, + 288.55641558766365, + 288.15108351409435, + 289.39511999487877, + 287.79830131679773, + 287.6054663211107, + 287.3081397265196, + 287.5107442960143, + 287.3228080570698, + 287.9091138020158, + 287.61894907802343, + 287.33131289482117, + 295.45536544173956, + 287.3565470799804, + 289.6707756444812, + 294.7502164170146, + 291.3138959556818, + 289.9140976369381, + 288.167810998857, + 296.3099963963032, + 287.8485172986984, + 287.88451105356216, + 287.4615266919136, + 300.6117632612586, + 287.12907526642084, + 299.74247701466084, + 295.96307035535574, + 307.2430994361639, + 302.7704805135727, + 297.1626240760088, + 294.2256275564432, + 299.9783093109727, + 296.0708010941744, + 296.902846544981, + 310.8699582517147, + 299.01127330958843 + ], + "p50_ms": 289.53294781968, + "p95_ms": 302.7704805135727, + "requests_per_second_serial": 3.4232982541891026, + "peak_allocated_bytes": 9699164160, + "peak_reserved_bytes": 10567548928 + } + } + ] + }, + { + "id": "640x480-short-q8", + "size": [ + 640, + 480 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 8, + "status": "complete", + "fixture_sha256": "038faab1159fdf610cb0c828b6c9e7cb12ee95a82539b9639f283530c99b5bf7", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 8, + "language": 8, + "image_preprocess": 8 + }, + "reuse_counts": { + "vision": 1, + "language": 8, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q2": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q3": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q4": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q5": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q6": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q7": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q8": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + } + }, + "usage": { + "input_tokens": 3648, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 1221.4117525145411, + 1099.8817589133978, + 1115.8878430724144, + 1125.741608440876, + 1094.5779541507363, + 1063.3284216746688, + 1118.4086594730616, + 1317.0162104070187, + 1195.4664466902614, + 1339.6971467882395, + 1318.5394778847694, + 1116.3709023967385, + 1104.728844948113, + 1130.8023892343044, + 1081.5342525020242, + 1044.0831957384944, + 1093.3213122189045, + 1061.1886382102966, + 1110.4030134156346, + 1053.03805321455, + 1023.5436009243131, + 1012.3143773525953, + 1110.8560543507338, + 1067.8950436413288, + 1086.7763925343752, + 1054.8501750454307, + 1093.9670400694013, + 1072.0825884491205, + 1110.1080728694797, + 1082.4691327288747, + 1099.1481700912118, + 1036.6211282089353, + 1100.337890908122, + 1055.8178005740047, + 1091.811970807612, + 1074.787748977542, + 1012.6693388447165, + 1082.6677670702338, + 1073.7507184967399, + 1045.7963682711124, + 1090.688357129693, + 1063.4702118113637, + 1099.3859712034464, + 1061.0204730182886, + 1101.3255724683404, + 1055.0267128273845, + 1128.263763152063, + 1105.738814920187, + 1093.6001939699054, + 1077.6757774874568 + ], + "p50_ms": 1092.5666415132582, + "p95_ms": 1317.0162104070187, + "requests_per_second_serial": 0.9079370843187994, + "peak_allocated_bytes": 9545779712, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 924.6495245024562, + 907.6285399496555, + 910.3873493149877, + 930.215822532773, + 910.1902078837156, + 928.7702953442931, + 906.7544937133789, + 954.1922491043806, + 1098.1662459671497, + 1034.6598522737622, + 914.7181529551744, + 916.8722638860345, + 910.6801776215434, + 897.328794002533, + 881.3934940844774, + 864.4113633781672, + 874.4823150336742, + 864.0994317829609, + 863.7787057086825, + 867.4580687656999, + 865.4584940522909, + 893.6479082331061, + 877.7996934950352, + 863.949865102768, + 874.2026798427105, + 863.4180389344692, + 871.1975328624249, + 859.693449921906, + 876.1273957788944, + 869.2982466891408, + 879.2446926236153, + 853.9124941453338, + 880.4389573633671, + 854.5185318216681, + 858.2283798605204, + 867.6332142204046, + 874.8911647126079, + 869.8497861623764, + 892.7463153377175, + 859.9625695496798, + 874.5414335280657, + 861.2501639872789, + 868.8429826870561, + 870.8343971520662, + 868.4824788942933, + 874.9992940574884, + 885.3493938222528, + 883.5007939487696, + 872.6213984191418, + 853.7234226241708 + ], + "p50_ms": 874.7162991203368, + "p95_ms": 954.1922491043806, + "requests_per_second_serial": 1.1240703301619546, + "peak_allocated_bytes": 9490196992, + "peak_reserved_bytes": 10567548928 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 1021.0056379437447, + 1039.8393971845508, + 1077.3269720375538, + 1111.6182785481215, + 1082.3289714753628, + 1108.5726721212268, + 1089.0448214486241, + 1066.8455380946398, + 1096.6647947207093, + 1113.8865426182747, + 1067.9116901010275, + 1101.9669882953167, + 1092.2089172527194, + 1105.9907265007496, + 1106.0045575723052, + 1120.4450782388449, + 1136.3842003047466, + 1096.6193992644548, + 1271.3322835043073, + 1128.4936536103487, + 1092.9638119414449, + 1089.235900901258, + 1339.7746533155441, + 1211.4816475659609, + 1091.9167464599013, + 1100.3206260502338, + 1117.867630906403, + 1131.844469346106, + 1096.9888223335147, + 1106.6317530348897, + 1053.2909240573645, + 1095.1922852545977, + 1272.3941560834646, + 1175.000204704702, + 1063.16233612597, + 1107.9540383070707, + 1093.8573004677892, + 1092.1178869903088, + 1048.0514084920287, + 1113.5527435690165, + 1049.7767198830843, + 1096.6883888468146, + 1054.7608556225896, + 1146.9593858346343, + 1096.9258220866323, + 1079.7770218923688, + 1057.7371213585138, + 1095.583138987422, + 1040.2352781966329, + 1104.4199522584677 + ], + "p50_ms": 1096.676591783762, + "p95_ms": 1271.3322835043073, + "requests_per_second_serial": 0.9033267947460158, + "peak_allocated_bytes": 9545779712, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 865.3683867305517, + 871.7433903366327, + 912.3460184782743, + 876.447418704629, + 870.2202644199133, + 923.2175191864371, + 906.6986348479986, + 915.3268234804273, + 890.1564180850983, + 917.6263939589262, + 905.4580926895142, + 902.2429017350078, + 906.1819035559893, + 901.6654277220368, + 889.6862808614969, + 933.0999935045838, + 905.9519292786717, + 919.2851167172194, + 1071.207451634109, + 918.5731997713447, + 906.4419064670801, + 918.3008885011077, + 917.8227828815579, + 908.8384239003062, + 914.6575126796961, + 976.2279614806175, + 912.7612067386508, + 916.1358047276735, + 892.8995626047254, + 886.275727301836, + 866.750206798315, + 879.674063064158, + 865.810046903789, + 876.8572192639112, + 877.4209646508098, + 902.5711193680763, + 890.8562771975994, + 874.2299741134048, + 860.1370817050338, + 878.2991543412209, + 866.9046051800251, + 879.812004044652, + 865.9599758684635, + 878.8152644410729, + 900.4343254491687, + 877.1974984556437, + 866.5986582636833, + 880.3332271054387, + 874.0388760343194, + 876.3488344848156 + ], + "p50_ms": 891.8779199011624, + "p95_ms": 933.0999935045838, + "requests_per_second_serial": 1.1137863090085776, + "peak_allocated_bytes": 9490196992, + "peak_reserved_bytes": 10567548928 + } + } + ] + }, + { + "id": "640x480-distinct-q8", + "status": "complete", + "fixture_sha256": "2f508d5412387edbd4f85e216568095990a63d1909a12e5c0635373116c7b7b2", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 8, + "language": 8, + "image_preprocess": 8 + }, + "reuse_counts": { + "vision": 1, + "language": 8, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "0d717f46abbc57e2696c66d4969fc777e96415a6f67740a7087cf77d78de218d" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "ff71ef4e6c311c56cd3dbe484f8a05773dba0361b21e97745ca7394758319d1c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "eb7ea7dd8487457bc025d44ba5ebc1550026250abea05f847d61b8ea6f52af8e" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "60b6d77d34ada12b8def875237be8cd0feee4475ccf4cb389bd44245b21a8f9d" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "c0e9e08d7a1863b1e91cca10457d593e1281ccd5695cfb89683b8121826cff38" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8de01e028cd92e75ba21cf901916223dc844a7c580f8bb2b943828403cb28198" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "cc047cd8ed2d1ddd4493abd7cff8ee7ba9fcd0b6265e1a1b8b4b2f6c6e822390" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "6fd0e47d02ff77335d5b2733962a9f7a1caed5ea867aa67b8c3b4b788509dba1" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "deb3cc137c72ac7e023b78a4d29d507ddf95f02f2572e38dd068a3574116ac21" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 443, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "c108e3059ad63ab2efd4d2d194766ab18ef6144819985ff6448dae85f476b032" + }, + "position_ids": { + "shape": [ + 3, + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "9e4fd6391bea467b1a278b2506d278b0ae583fc15a686a31882dc377374e04d1" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 442, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "db88bedddbbd1d2b6aaf63664379d5206b0de9ef3fcf0ccdd0fb951599364847" + }, + "position_ids": { + "shape": [ + 3, + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "f706ff63624d02735d39ebe7097dc53d833763276475713d80259d5fed6d7446" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 426, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "b464ff04b79496dcab96f3a8b588a4bc5e611075d4e44ff7b526eaa685658b4a" + }, + "position_ids": { + "shape": [ + 3, + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "edacad438038fb1d85e9097dd2de086c8f14696351353792f13df88e99e9de7b" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 752, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cd572e59171ef52d8e37644cbbdbbf9ff86d77d31cf48b19c4821d7349c026f7" + }, + "position_ids": { + "shape": [ + 3, + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "3d615db0cf3b07f33f32c5d24335f9abdd5b4599e5de79b20326f339520128d1" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 469, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "fecbffc833f744dd32c6b0296b399ef7256ded521c75fd8a5dfb2fd6f5e3c762" + }, + "position_ids": { + "shape": [ + 3, + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "a679452a2039eff05da911d8657b1857f058184d4bb373cd35576f7d3bfca410" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "a075316b24c03cafe09f612e8c4499e0c87035b098bf3db6f8023f7be18c405d" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 460, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0472dbfc0ad390d48f2d4340f8688dfb77298cede625d8d070c3ec3648cd712b" + }, + "position_ids": { + "shape": [ + 3, + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "506ff79aaba73a3bd70f9b1fac38badd9497de8377e2db255b1322b7ae308b86" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cb1f6fae46aaeb1f6b21beafd94e066b87b0bd4a02e7f10bf6f0e991cbc43f49" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.998498797416687, + "cancel": 0.0015011822106316686 + }, + "confidence": 0.9837552323853659 + }, + "q2": { + "type": "choice", + "choice": "cancel", + "probabilities": { + "cancel": 0.9995121955871582, + "save": 0.00048785717808641493 + }, + "confidence": 0.9939293781678539 + }, + "q3": { + "type": "choice", + "choice": "only", + "probabilities": { + "only": 1.0 + }, + "confidence": 1.0 + }, + "q4": { + "type": "choice", + "choice": "option-3", + "probabilities": { + "option-0": 0.07546718418598175, + "option-1": 0.00034948240499943495, + "option-2": 0.263406366109848, + "option-3": 0.557631254196167, + "option-4": 0.009013270027935505, + "option-5": 0.01908109337091446, + "option-6": 0.007019542157649994, + "option-7": 0.016839005053043365, + "option-8": 0.009013270027935505, + "option-9": 0.0025823453906923532, + "option-10": 0.004824455827474594, + "option-11": 0.003315796609967947, + "option-12": 0.002011132426559925, + "option-13": 0.0022789116483181715, + "option-14": 0.00619472423568368, + "option-15": 0.0010764816543087363, + "option-16": 0.0037572900764644146, + "option-17": 0.0006529190577566624, + "option-18": 0.002011132426559925, + "option-19": 0.0012198134791105986, + "option-20": 0.00044874430750496686, + "option-21": 0.0005084939184598625, + "option-22": 0.003315796609967947, + "option-23": 0.0013822298496961594, + "option-24": 0.0017748181708157063, + "option-25": 0.004824455827474594 + }, + "confidence": 0.5755459268738158 + }, + "q5": { + "type": "choice", + "choice": "object", + "probabilities": { + "null": 0.07443060725927353, + "object": 0.9067503809928894, + "array": 0.01881900243461132 + }, + "confidence": 0.6751463333759231 + }, + "q6": { + "type": "choice", + "choice": "first", + "probabilities": { + "first": 0.531209409236908, + "second": 0.4687906503677368 + }, + "confidence": 0.002812297157495758 + }, + "q7": { + "type": "choice", + "choice": "yes", + "probabilities": { + "yes": 0.9823379516601562, + "no": 0.0035428637638688087, + "wait": 0.006618940737098455, + "help": 0.007500242441892624 + }, + "confidence": 0.9225223144825633 + }, + "q8": { + "type": "choice", + "choice": "leave", + "probabilities": { + "stay": 0.01798621006309986, + "leave": 0.9820137619972229 + }, + "confidence": 0.8700206851739604 + } + }, + "usage": { + "input_tokens": 3874, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 1043.482962064445, + 1058.152531273663, + 1090.8771408721805, + 1267.0033294707537, + 1200.5286160856485, + 1025.9398464113474, + 1110.5567812919617, + 1067.6514701917768, + 1109.4025950878859, + 1059.7281903028488, + 1102.9173033311963, + 1102.3784950375557, + 1086.6984045132995, + 1092.9609574377537, + 1105.8079600334167, + 1072.3348036408424, + 1130.6934487074614, + 1073.5906846821308, + 1076.3352550566196, + 1164.351413026452, + 1132.9496446996927, + 1140.0006972253323, + 1134.9129164591432, + 1139.7405983880162, + 1112.454908899963, + 1102.7401564642787, + 1072.806722484529, + 1139.0567226335406, + 1140.4839819297194, + 1171.2292023003101, + 1096.5198185294867, + 1092.7736833691597, + 1100.7973663508892, + 1143.0003205314279, + 1123.756255954504, + 1045.1623648405075, + 1089.976029470563, + 1057.715404778719, + 1103.359455242753, + 1033.1290401518345, + 1120.3042697161436, + 1050.3293108195066, + 1138.4463785216212, + 1088.549979031086, + 1096.0353799164295, + 1053.3616794273257, + 1099.2530193179846, + 1047.8089032694697, + 1125.8206963539124, + 1047.0253443345428 + ], + "p50_ms": 1100.025192834437, + "p95_ms": 1171.2292023003101, + "requests_per_second_serial": 0.9077558075974788, + "peak_allocated_bytes": 9679890432, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 868.3407688513398, + 864.5068947225809, + 886.1960200592875, + 869.5981968194246, + 878.1103957444429, + 861.749897710979, + 863.4633030742407, + 865.4197491705418, + 862.2753396630287, + 865.6177558004856, + 877.4944832548499, + 859.9999314174056, + 911.9013398885727, + 906.4690424129367, + 898.6139502376318, + 899.4797328487039, + 899.6151871979237, + 909.172517247498, + 984.3312818557024, + 1069.9747269973159, + 906.6269909963012, + 905.953680165112, + 928.8740484043956, + 904.2298514395952, + 909.6393398940563, + 904.4137932360172, + 912.8351835533977, + 911.8297072127461, + 924.4161061942577, + 911.8905626237392, + 919.8187831789255, + 910.0017435848713, + 909.1631611809134, + 908.0140506848693, + 1011.8006700649858, + 898.2379576191306, + 874.3223687633872, + 867.8271370008588, + 868.349458090961, + 882.2032725438476, + 870.7024827599525, + 873.8000867888331, + 883.363020606339, + 888.8901649042964, + 875.6863363087177, + 866.6092967614532, + 873.2720576226711, + 875.9538298472762, + 878.6588357761502, + 873.2194779440761 + ], + "p50_ms": 887.543092481792, + "p95_ms": 984.3312818557024, + "requests_per_second_serial": 1.115251570032127, + "peak_allocated_bytes": 9655113728, + "peak_reserved_bytes": 10567548928 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 1123.1731800362468, + 1079.4411329552531, + 1039.7632727399468, + 1099.2255313321948, + 1063.1815725937486, + 1100.5753464996815, + 1044.0124785527587, + 1106.159239076078, + 1074.9673834070563, + 1146.0543712601066, + 1076.4180170372128, + 1078.0710969120264, + 1069.606107659638, + 1098.5850915312767, + 1036.3023551180959, + 1112.7971224486828, + 1045.1211407780647, + 1179.864008910954, + 1055.7633563876152, + 1093.4717962518334, + 1072.2836572676897, + 1090.2987504377961, + 1062.2489349916577, + 1113.5801766067743, + 1062.762132845819, + 1147.684191353619, + 1105.9822235256433, + 1119.2202614620328, + 1071.1866905912757, + 1082.582057453692, + 1098.0339087545872, + 1099.7226312756538, + 1076.7798507586122, + 1111.4978911355138, + 1069.8032779619098, + 1122.4801149219275, + 1308.827567845583, + 1162.612872198224, + 1093.265611678362, + 1069.4006765261292, + 1077.6846641674638, + 1101.7834367230535, + 1097.0233613625169, + 1123.2466446235776, + 1096.2603883817792, + 1103.7829229608178, + 1112.7562448382378, + 1114.5546231418848, + 1076.5267191454768, + 1088.7574227526784 + ], + "p50_ms": 1094.8660923168063, + "p95_ms": 1162.612872198224, + "requests_per_second_serial": 0.9114908893091921, + "peak_allocated_bytes": 9679890432, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 884.0020904317498, + 888.3904190734029, + 860.644849948585, + 874.219773337245, + 866.0228736698627, + 869.6495648473501, + 878.3435057848692, + 872.1114145591855, + 878.7399781867862, + 888.5009894147515, + 869.7494985535741, + 878.2469602301717, + 870.0400684028864, + 878.9007375016809, + 872.2844664007425, + 869.494678452611, + 873.4422009438276, + 883.6865667253733, + 881.5564541146159, + 873.7641936168075, + 860.7141766697168, + 871.142621152103, + 858.5151117295027, + 859.6103768795729, + 871.0338184610009, + 916.5979139506817, + 967.9431840777397, + 904.898764565587, + 911.1284539103508, + 913.3932655677199, + 901.6105886548758, + 899.3697101250291, + 916.9316962361336, + 902.4454765021801, + 912.4608309939504, + 914.2494592815638, + 1006.927109323442, + 907.4635952711105, + 904.5701157301664, + 916.1155205219984, + 914.1925135627389, + 913.0416037514806, + 894.0904764458537, + 963.1947260349989, + 912.1640203520656, + 954.5158687978983, + 915.9884378314018, + 900.2738101407886, + 912.2229432687163, + 873.2004882767797 + ], + "p50_ms": 888.4457042440772, + "p95_ms": 963.1947260349989, + "requests_per_second_serial": 1.116525067665529, + "peak_allocated_bytes": 9655113728, + "peak_reserved_bytes": 10567548928 + } + } + ] + }, + { + "id": "320x240-short-q1", + "size": [ + 320, + 240 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 1, + "status": "complete", + "fixture_sha256": "aead58362464cdd081f40f4aa18988d993e5062b24c5cdeef0e1a67b085459b5", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + } + }, + "usage": { + "input_tokens": 236, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 109.49226841330528, + 108.24568383395672, + 108.70138742029667, + 108.74505341053009, + 108.70999936014414, + 108.61261654645205, + 108.55097882449627, + 108.28586388379335, + 108.50361362099648, + 112.9041537642479, + 109.93217770010233, + 108.25086291879416, + 108.6167898029089, + 108.31590089946985, + 108.59769023954868, + 108.3840262144804, + 108.39788522571325, + 110.04923097789288, + 108.82530175149441, + 111.76346987485886, + 108.88205748051405, + 107.26235341280699, + 107.39369038492441, + 107.21014905720949, + 107.42908902466297, + 107.83827304840088, + 107.43067041039467, + 107.5232420116663, + 107.6956083998084, + 107.49123338609934, + 113.19504771381617, + 107.9621547833085, + 107.4793366715312, + 107.73422848433256, + 107.76066593825817, + 107.52343665808439, + 107.72616695612669, + 107.90042672306299, + 107.52703342586756, + 107.42691345512867, + 112.39762231707573, + 107.7637579292059, + 107.92182106524706, + 107.94051643460989, + 111.66147701442242, + 108.27931948006153, + 107.40425158292055, + 107.6588649302721, + 107.97281097620726, + 107.39882662892342 + ], + "p50_ms": 108.10924740508199, + "p95_ms": 112.39762231707573, + "requests_per_second_serial": 9.213743366230815, + "peak_allocated_bytes": 9371223040, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 108.69818180799484, + 108.46790578216314, + 108.21706429123878, + 108.0867126584053, + 108.53662807494402, + 108.43003820627928, + 108.80451183766127, + 108.4781102836132, + 108.1719072535634, + 108.17495360970497, + 108.88720490038395, + 108.38632378727198, + 108.56468509882689, + 108.43167454004288, + 109.25214551389217, + 108.43463987112045, + 108.5692411288619, + 108.40058978646994, + 108.4162537008524, + 108.28196723014116, + 111.99398897588253, + 107.5283968821168, + 107.31910355389118, + 107.40750376135111, + 107.45173133909702, + 109.320935793221, + 107.41297155618668, + 107.54942428320646, + 107.41663072258234, + 107.51574672758579, + 107.7790129929781, + 107.85318538546562, + 107.55933448672295, + 107.24393464624882, + 107.80473705381155, + 107.97826014459133, + 107.80642740428448, + 107.63240233063698, + 108.08779951184988, + 107.58385714143515, + 109.76205673068762, + 108.28248970210552, + 107.71558713167906, + 107.6364517211914, + 107.54588712006807, + 107.80231654644012, + 107.50650893896818, + 107.5785905122757, + 107.74162225425243, + 112.59841453284025 + ], + "p50_ms": 108.08725608512759, + "p95_ms": 109.76205673068762, + "requests_per_second_serial": 9.238547719691455, + "peak_allocated_bytes": 9371223040, + "peak_reserved_bytes": 10567548928 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 113.55145834386349, + 112.60463204234838, + 111.63413617759943, + 113.67962788790464, + 108.29773917794228, + 107.7667260542512, + 107.70486015826464, + 108.12488198280334, + 112.27497272193432, + 108.99531282484531, + 116.12135544419289, + 108.97277481853962, + 109.56979636102915, + 108.94082859158516, + 108.31994749605656, + 108.17987099289894, + 107.80800599604845, + 107.59843979030848, + 107.90672991424799, + 108.12581237405539, + 108.04708395153284, + 112.78395913541317, + 107.90060646831989, + 108.11049025505781, + 107.859724201262, + 110.61881296336651, + 108.2851318642497, + 107.896339148283, + 108.02760161459446, + 108.17757621407509, + 111.04282736778259, + 108.38706884533167, + 107.93765541166067, + 107.98293352127075, + 108.15971065312624, + 107.8819241374731, + 109.4562029466033, + 108.3550276234746, + 107.54369478672743, + 107.62098431587219, + 114.60543517023325, + 108.41377172619104, + 108.26053842902184, + 108.13737194985151, + 108.02850779145956, + 108.20035170763731, + 107.93161392211914, + 107.79760498553514, + 107.89498500525951, + 108.05362090468407 + ], + "p50_ms": 108.16864343360066, + "p95_ms": 113.67962788790464, + "requests_per_second_serial": 9.164933313849838, + "peak_allocated_bytes": 9371223040, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 120.98739948123693, + 116.18727166205645, + 108.19284152239561, + 108.17911569029093, + 108.10589045286179, + 108.13646670430899, + 108.0222362652421, + 108.16989094018936, + 108.61433390527964, + 113.78944665193558, + 122.47773259878159, + 107.85950254648924, + 107.56330844014883, + 109.275471419096, + 108.08762069791555, + 107.8311363235116, + 108.09444822371006, + 107.85157699137926, + 108.02438482642174, + 108.03712904453278, + 115.0760380551219, + 107.86899924278259, + 108.02010353654623, + 107.98196773976088, + 108.0816863104701, + 107.96204954385757, + 107.74271748960018, + 108.03087148815393, + 108.29470679163933, + 107.89347440004349, + 110.30581127852201, + 107.99373593181372, + 108.04933216422796, + 107.93630871921778, + 108.03583264350891, + 107.45061095803976, + 107.71466046571732, + 108.59510488808155, + 107.86398500204086, + 107.2612926363945, + 107.66883287578821, + 110.4331873357296, + 108.60312264412642, + 107.99762140959501, + 108.76358207315207, + 108.03825780749321, + 108.29458571970463, + 107.90352523326874, + 108.03703870624304, + 107.92102105915546 + ], + "p50_ms": 108.0370838753879, + "p95_ms": 116.18727166205645, + "requests_per_second_serial": 9.165386574715091, + "peak_allocated_bytes": 9371223040, + "peak_reserved_bytes": 10567548928 + } + } + ] + }, + { + "id": "320x240-long-q1", + "size": [ + 320, + 240 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 1, + "status": "complete", + "fixture_sha256": "b296166e1ccdeb4003c2c90c4b2b57335d64f657f72806fa95042a8c8d1579de", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 614, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "7dcdd73c6c7ed152963408f5d27174d01a49402bb537d819a68d59588a53984e" + }, + "position_ids": { + "shape": [ + 3, + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "8a75647b9a14785031d9b56d339545518f2603ae1b16f65e959f3d953d61ef68" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9926069974899292, + "cancel": 0.0007049240521155298, + "wait": 0.006688133347779512 + }, + "confidence": 0.9581546345308546 + } + }, + "usage": { + "input_tokens": 614, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 135.6040807440877, + 135.95078606158495, + 134.88993607461452, + 135.40860638022423, + 135.4619413614273, + 135.00480260699987, + 135.6239626184106, + 135.70281863212585, + 142.31502637267113, + 134.99146793037653, + 134.97353717684746, + 135.45475993305445, + 137.99340184777975, + 144.24240123480558, + 143.7200764194131, + 136.28585264086723, + 135.52484940737486, + 136.2569248303771, + 136.51398941874504, + 144.24637984484434, + 141.39807876199484, + 141.48276206105947, + 136.48198917508125, + 135.74793096631765, + 135.9116742387414, + 136.13770809024572, + 136.55585329979658, + 136.31196226924658, + 136.43970247358084, + 135.17457619309425, + 135.48514991998672, + 135.44962462037802, + 135.08857693523169, + 135.56427508592606, + 135.23983303457499, + 135.3186797350645, + 135.09663380682468, + 136.21633034199476, + 135.28768718242645, + 135.42465306818485, + 135.38165576756, + 135.21455135196447, + 137.83291820436716, + 135.24444866925478, + 135.55957190692425, + 135.5913644656539, + 135.2059319615364, + 135.50203014165163, + 135.3400768712163, + 135.27201674878597 + ], + "p50_ms": 135.56192349642515, + "p95_ms": 143.7200764194131, + "requests_per_second_serial": 7.322655696727378, + "peak_allocated_bytes": 9584474112, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 135.65992377698421, + 137.23747711628675, + 140.05521591752768, + 136.84048037976027, + 135.16779989004135, + 135.40127966552973, + 135.37290412932634, + 135.4067288339138, + 135.24100184440613, + 135.10198052972555, + 140.35410154610872, + 140.46486373990774, + 145.50580643117428, + 144.64353118091822, + 145.02956625074148, + 145.02498228102922, + 137.2672514989972, + 136.7563121020794, + 141.7538858950138, + 137.48103938996792, + 138.0382962524891, + 142.40360260009766, + 136.18544209748507, + 136.34192571043968, + 136.25164702534676, + 136.56819891184568, + 144.42359190434217, + 136.92890480160713, + 136.2571381032467, + 135.27405634522438, + 135.21773926913738, + 135.2780731394887, + 135.28872933238745, + 135.5723049491644, + 138.06145545095205, + 137.10675574839115, + 134.6892062574625, + 135.30959375202656, + 135.45614201575518, + 135.35311166197062, + 134.92250815033913, + 134.6319941803813, + 136.90480776131153, + 136.9307218119502, + 135.10894402861595, + 135.15829015523195, + 135.41531469672918, + 135.69748681038618, + 135.41810307651758, + 135.5621786788106 + ], + "p50_ms": 136.2185445614159, + "p95_ms": 145.02498228102922, + "requests_per_second_serial": 7.280646077145649, + "peak_allocated_bytes": 9584474112, + "peak_reserved_bytes": 10567548928 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 141.22610352933407, + 139.99813701957464, + 135.24496834725142, + 136.31719630211592, + 135.55942755192518, + 135.1774400100112, + 135.72583626955748, + 135.5199422687292, + 135.64384263008833, + 141.88212249428034, + 135.7800541445613, + 135.34060213714838, + 135.55051665753126, + 135.73612924665213, + 135.06371527910233, + 135.361653752625, + 135.377774015069, + 149.04390648007393, + 135.50118077546358, + 165.02394806593657, + 135.36522444337606, + 137.15508673340082, + 136.47279143333435, + 137.8210261464119, + 135.3828702121973, + 135.53074654191732, + 135.39645913988352, + 135.3666391223669, + 141.05308335274458, + 142.83188804984093, + 135.70775836706161, + 135.47844253480434, + 136.49588730186224, + 142.1492239460349, + 135.0945048034191, + 135.20304299890995, + 134.97273717075586, + 135.0083602592349, + 135.3339347988367, + 135.3778773918748, + 134.98114608228207, + 138.40366154909134, + 136.31229847669601, + 136.22604962438345, + 135.85975114256144, + 135.80582849681377, + 135.99153142422438, + 135.32806001603603, + 135.7580116018653, + 135.6117408722639 + ], + "p50_ms": 135.62779175117612, + "p95_ms": 142.83188804984093, + "requests_per_second_serial": 7.2848597048253, + "peak_allocated_bytes": 9584474112, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 135.1760346442461, + 136.11784484237432, + 135.60864608734846, + 135.39677020162344, + 135.36831084638834, + 135.7709290459752, + 136.52477972209454, + 135.4007413610816, + 135.28430368751287, + 136.70036848634481, + 135.70244051516056, + 135.36639511585236, + 135.42988803237677, + 135.20197290927172, + 135.174754075706, + 135.29400993138552, + 135.29422227293253, + 144.43413261324167, + 135.756503790617, + 136.2016098573804, + 135.7156503945589, + 136.53223682194948, + 138.94190080463886, + 140.87172411382198, + 136.83025166392326, + 138.99097125977278, + 136.3477734848857, + 135.17192844301462, + 135.42361743748188, + 140.87159931659698, + 140.51578752696514, + 135.1415514945984, + 135.45996136963367, + 135.25344338268042, + 135.08084788918495, + 135.45197248458862, + 134.91780124604702, + 135.65693236887455, + 135.6706665828824, + 135.09694766253233, + 135.04887837916613, + 140.97444340586662, + 135.39043441414833, + 135.9022818505764, + 135.64740400761366, + 135.77224127948284, + 135.89703477919102, + 135.91042254120111, + 135.79247053712606, + 144.2690221592784 + ], + "p50_ms": 135.66379947587848, + "p95_ms": 140.97444340586662, + "requests_per_second_serial": 7.325199292513105, + "peak_allocated_bytes": 9584474112, + "peak_reserved_bytes": 10567548928 + } + } + ] + }, + { + "id": "640x480-short-q4", + "size": [ + 640, + 480 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 4, + "status": "complete", + "fixture_sha256": "6037fb3cd53ef28ce14c3d278c81974cb4bd859c15a2905de5e3bc811b77b901", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 4, + "language": 4, + "image_preprocess": 4 + }, + "reuse_counts": { + "vision": 1, + "language": 4, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q2": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q3": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q4": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + } + }, + "usage": { + "input_tokens": 1824, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 519.6475498378277, + 516.2776913493872, + 526.3339057564735, + 515.321334823966, + 527.3834578692913, + 514.9613600224257, + 519.6666335687041, + 518.9991798251867, + 508.54097306728363, + 528.0532874166965, + 516.0699039697647, + 534.413194283843, + 520.7670824602246, + 507.80558958649635, + 516.2527430802584, + 514.7024728357792, + 515.9984193742275, + 517.6475597545505, + 509.548706933856, + 544.844364747405, + 531.2139624729753, + 530.8154970407486, + 532.9321548342705, + 543.3851405978203, + 537.9505045711994, + 537.4153256416321, + 546.5757260099053, + 547.7554528042674, + 541.8553426861763, + 547.4087940528989, + 567.4517685547471, + 540.7807761803269, + 557.5277246534824, + 539.9515926837921, + 577.8621211647987, + 529.7452202066779, + 543.3747069910169, + 543.6198450624943, + 540.252685546875, + 526.9185323268175, + 527.7461986988783, + 528.8485521450639, + 533.1212235614657, + 537.767456844449, + 531.0886856168509, + 537.0161551982164, + 538.4366447106004, + 557.4731286615133, + 582.8576264902949, + 570.6851873546839 + ], + "p50_ms": 532.0730586536229, + "p95_ms": 570.6851873546839, + "requests_per_second_serial": 1.8724439400767676, + "peak_allocated_bytes": 9515082240, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 449.3250483646989, + 446.8002486974001, + 474.6831450611353, + 446.7774126678705, + 449.42054245620966, + 450.7705718278885, + 446.0997898131609, + 450.90894866734743, + 439.8612445220351, + 444.11907717585564, + 446.24043069779873, + 444.3595977500081, + 446.2281847372651, + 442.0214658603072, + 442.62524880468845, + 445.3599499538541, + 447.9651367291808, + 442.9739210754633, + 456.3922015950084, + 456.7754538729787, + 478.794957511127, + 473.12343679368496, + 457.05557335168123, + 469.7803966701031, + 462.9286536946893, + 462.68376614898443, + 475.769710727036, + 465.4472516849637, + 466.573697514832, + 463.6344062164426, + 452.72652339190245, + 467.16349478811026, + 468.8250804319978, + 451.39278657734394, + 469.8922047391534, + 464.30356707423925, + 474.3853658437729, + 459.71042197197676, + 468.2288495823741, + 470.2014969661832, + 467.377339489758, + 458.98595452308655, + 470.69416008889675, + 514.6505478769541, + 470.84443271160126, + 479.42028380930424, + 465.5026011168957, + 458.0245018005371, + 466.0640833899379, + 468.7330527231097 + ], + "p50_ms": 461.1970940604806, + "p95_ms": 478.794957511127, + "requests_per_second_serial": 2.172720293763918, + "peak_allocated_bytes": 9490196992, + "peak_reserved_bytes": 10567548928 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 530.1492111757398, + 539.5813658833504, + 544.3888325244188, + 536.2419188022614, + 536.2168345600367, + 531.3837854191661, + 602.0504543557763, + 550.2020483836532, + 531.5085472539067, + 541.9999081641436, + 553.800349123776, + 533.8707799091935, + 550.366597250104, + 540.3692573308945, + 539.8912271484733, + 549.9522211030126, + 547.2446139901876, + 607.9746149480343, + 517.8367132321, + 523.1117904186249, + 513.5606937110424, + 522.0167422667146, + 519.7643078863621, + 513.6862555518746, + 517.9988760501146, + 508.61888006329536, + 522.3533930256963, + 515.718586742878, + 515.8550785854459, + 512.2046889737248, + 534.0086035430431, + 541.9681388884783, + 517.9077358916402, + 513.7051604688168, + 507.22297094762325, + 505.4408283904195, + 512.9621867090464, + 519.0153392031789, + 512.9287587478757, + 523.7618926912546, + 509.61359310895205, + 513.3126247674227, + 517.6379475742579, + 518.6017276719213, + 515.3456768020988, + 517.8010361269116, + 510.28373278677464, + 508.2558011636138, + 513.0720632150769, + 520.9663510322571 + ], + "p50_ms": 520.3653294593096, + "p95_ms": 553.800349123776, + "requests_per_second_serial": 1.8936717877334972, + "peak_allocated_bytes": 9515082240, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 472.23728708922863, + 463.855367153883, + 463.7559726834297, + 481.8222410976887, + 458.37067160755396, + 468.15085876733065, + 472.261855378747, + 463.86247128248215, + 473.67401886731386, + 469.8280058801174, + 464.7843521088362, + 469.03083100914955, + 461.85324154794216, + 463.3791372179985, + 465.53858928382397, + 453.2269602641463, + 463.62791676074266, + 448.59691616147757, + 443.29294096678495, + 456.7119274288416, + 447.8162368759513, + 451.8223060294986, + 446.10550068318844, + 442.36218743026257, + 447.4074076861143, + 440.1722615584731, + 446.4216260239482, + 443.25136486440897, + 439.726191572845, + 452.33982987701893, + 443.82481183856726, + 456.6643452271819, + 446.19380682706833, + 443.30729357898235, + 442.58476234972477, + 443.5345437377691, + 441.10021088272333, + 451.2377576902509, + 445.8215283229947, + 446.7372726649046, + 443.4589073061943, + 446.68417796492577, + 447.36263807862997, + 446.09251618385315, + 442.5711566582322, + 446.02470099925995, + 443.31745337694883, + 463.1230104714632, + 472.86763321608305, + 464.2436234280467 + ], + "p50_ms": 449.9173369258642, + "p95_ms": 472.86763321608305, + "requests_per_second_serial": 2.2014756501357398, + "peak_allocated_bytes": 9490196992, + "peak_reserved_bytes": 10567548928 + } + } + ] + }, + { + "id": "640x480-long-q4", + "size": [ + 640, + 480 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 4, + "status": "complete", + "fixture_sha256": "1c19cdfff47913f946685a1395818eb8a5fa31b1c96c2291d9ea8f28d73602eb", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 4, + "language": 4, + "image_preprocess": 4 + }, + "reuse_counts": { + "vision": 1, + "language": 4, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 834, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0f4933b9cd8920b9f60b0202f44a126bf595fcb1618c173f630cb6d23d49a0c6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "290e2e206a836ca5c2d731a28a73a88ddf11e4b46f3bb9df108c6761c783ef08" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 834, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0f4933b9cd8920b9f60b0202f44a126bf595fcb1618c173f630cb6d23d49a0c6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "290e2e206a836ca5c2d731a28a73a88ddf11e4b46f3bb9df108c6761c783ef08" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 834, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0f4933b9cd8920b9f60b0202f44a126bf595fcb1618c173f630cb6d23d49a0c6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "290e2e206a836ca5c2d731a28a73a88ddf11e4b46f3bb9df108c6761c783ef08" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 834, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0f4933b9cd8920b9f60b0202f44a126bf595fcb1618c173f630cb6d23d49a0c6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "290e2e206a836ca5c2d731a28a73a88ddf11e4b46f3bb9df108c6761c783ef08" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9877169728279114, + "cancel": 0.0013104835525155067, + "wait": 0.010972544550895691 + }, + "confidence": 0.9359032375170542 + }, + "q2": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9877169728279114, + "cancel": 0.0013104835525155067, + "wait": 0.010972544550895691 + }, + "confidence": 0.9359032375170542 + }, + "q3": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9877169728279114, + "cancel": 0.0013104835525155067, + "wait": 0.010972544550895691 + }, + "confidence": 0.9359032375170542 + }, + "q4": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9877169728279114, + "cancel": 0.0013104835525155067, + "wait": 0.010972544550895691 + }, + "confidence": 0.9359032375170542 + } + }, + "usage": { + "input_tokens": 3336, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 615.5093032866716, + 616.4457043632865, + 615.2143813669682, + 615.8636622130871, + 616.0979932174087, + 638.3669078350067, + 667.7779192104936, + 626.9089141860604, + 630.8499509468675, + 618.0539969354868, + 621.4899998158216, + 617.2943180426955, + 617.1156140044332, + 624.2327569052577, + 617.266514338553, + 631.4947670325637, + 621.3076477870345, + 628.8127321749926, + 630.0115324556828, + 644.789807498455, + 620.3032350167632, + 620.6526532769203, + 619.3911181762815, + 619.6246473118663, + 620.5109935253859, + 621.6013114899397, + 792.2163819894195, + 621.203183196485, + 619.6893490850925, + 620.8565849810839, + 620.458310469985, + 629.977316595614, + 625.801581889391, + 641.2956090644002, + 675.0371288508177, + 639.1773642972112, + 647.6933658123016, + 667.3600813373923, + 771.1672652512789, + 640.9708838909864, + 639.9799827486277, + 631.5476838499308, + 634.4887837767601, + 714.5231477916241, + 702.243690378964, + 643.1934274733067, + 648.7480346113443, + 638.0523955449462, + 669.0665790811181, + 648.869545198977 + ], + "p50_ms": 629.3950243853033, + "p95_ms": 714.5231477916241, + "requests_per_second_serial": 1.5614944922330494, + "peak_allocated_bytes": 9724983808, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 560.1548161357641, + 552.8749264776707, + 563.1375396624207, + 552.4529926478863, + 552.802961319685, + 554.0054924786091, + 556.2885003164411, + 569.0884999930859, + 554.7240898013115, + 556.6921373829246, + 552.8182089328766, + 552.8708230704069, + 553.2784722745419, + 553.3155808225274, + 556.2298418954015, + 556.9322686642408, + 558.2435373216867, + 554.2616453021765, + 555.2232237532735, + 572.8027271106839, + 567.268842831254, + 569.2245345562696, + 553.4800319001079, + 556.3544454053044, + 553.7998303771019, + 559.3811590224504, + 663.4137742221355, + 557.8195936977863, + 580.6020274758339, + 554.5549243688583, + 558.1101374700665, + 554.1644617915154, + 591.3271494209766, + 580.3034640848637, + 569.6494616568089, + 582.6620738953352, + 593.04035641253, + 580.2382910624146, + 691.7135501280427, + 612.7625033259392, + 579.4528974220157, + 600.6872840225697, + 590.4998891055584, + 581.5045973286033, + 590.3915651142597, + 586.5557761862874, + 587.8674909472466, + 590.936902910471, + 622.2062101587653, + 595.1973292976618 + ], + "p50_ms": 561.6461778990924, + "p95_ms": 622.2062101587653, + "requests_per_second_serial": 1.7425628993630058, + "peak_allocated_bytes": 9699164160, + "peak_reserved_bytes": 10567548928 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 645.8831103518605, + 644.0583942458034, + 640.7913472503424, + 637.1746305376291, + 638.05350381881, + 627.8790486976504, + 635.6489881873131, + 707.7186983078718, + 644.2520366981626, + 653.1295478343964, + 646.1165370419621, + 635.240868665278, + 669.1416818648577, + 648.1236405670643, + 670.9971968084574, + 657.8068677335978, + 644.6486627683043, + 644.4412283599377, + 649.9641248956323, + 644.1782768815756, + 645.983574911952, + 633.742518723011, + 621.9358714297414, + 616.7075661942363, + 618.0167403072119, + 628.2139215618372, + 618.6180608347058, + 625.7134238258004, + 656.4947506412864, + 617.9088978096843, + 617.2032197937369, + 620.2748715877533, + 622.9739794507623, + 625.6197355687618, + 650.0476766377687, + 622.8296170011163, + 625.4001129418612, + 622.0492655411363, + 627.7827536687255, + 621.4732686057687, + 626.4081113040447, + 620.8885572850704, + 622.1219915896654, + 620.5158531665802, + 624.0921029821038, + 752.1952399984002, + 636.0051017254591, + 622.8034626692533, + 625.26276987046, + 622.8251680731773 + ], + "p50_ms": 630.9782201424241, + "p95_ms": 670.9971968084574, + "requests_per_second_serial": 1.5675280137700214, + "peak_allocated_bytes": 9724983808, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 594.5097440853715, + 590.7923551276326, + 577.6940723881125, + 572.629283182323, + 580.8910680934787, + 593.9156776294112, + 576.3148246333003, + 568.8811056315899, + 570.7651907578111, + 568.8552157953382, + 575.4661075770855, + 577.8852226212621, + 585.3145346045494, + 580.917876213789, + 575.5347432568669, + 576.3327926397324, + 590.8612320199609, + 585.4606833308935, + 588.9062993228436, + 589.1969678923488, + 596.784321591258, + 557.2906620800495, + 553.6673115566373, + 563.5651331394911, + 553.8420211523771, + 555.8768371120095, + 556.9151118397713, + 557.8360017389059, + 556.8968551233411, + 553.4162512049079, + 553.1684374436736, + 557.9069023951888, + 553.4063959494233, + 554.4230453670025, + 563.332243822515, + 554.9350176006556, + 554.8144010826945, + 554.9417342990637, + 555.1154436543584, + 555.0043741241097, + 559.9390491843224, + 556.5787730738521, + 556.8672819063067, + 554.9298217520118, + 564.7974442690611, + 598.4414909034967, + 569.9672745540738, + 572.3722409456968, + 577.5919537991285, + 564.8573702201247 + ], + "p50_ms": 566.8562930077314, + "p95_ms": 594.5097440853715, + "requests_per_second_serial": 1.7568143014657924, + "peak_allocated_bytes": 9699164160, + "peak_reserved_bytes": 10567548928 + } + } + ] + }, + { + "id": "640x480-short-q2", + "size": [ + 640, + 480 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 2, + "status": "complete", + "fixture_sha256": "42a2f55a81bbcee5a93b58388d1af0515f66521bc3ceaf7c14190746baa1daaf", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 2, + "language": 2, + "image_preprocess": 2 + }, + "reuse_counts": { + "vision": 1, + "language": 2, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q2": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + } + }, + "usage": { + "input_tokens": 912, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 257.00098648667336, + 263.9961028471589, + 259.49932262301445, + 260.61111502349377, + 259.4335041940212, + 259.8069114610553, + 265.40299877524376, + 256.02859910577536, + 255.86524233222008, + 259.133187122643, + 255.88637124747038, + 255.92935178428888, + 255.43789099901915, + 256.8334564566612, + 255.47179952263832, + 256.3895070925355, + 255.12171164155006, + 275.4672020673752, + 270.3398894518614, + 263.4567217901349, + 255.72559982538223, + 263.26188165694475, + 259.5542762428522, + 255.1302732899785, + 261.16886641830206, + 254.3173087760806, + 254.409103654325, + 254.2581409215927, + 254.07637748867273, + 254.57486603409052, + 254.3755853548646, + 254.1422825306654, + 253.90090513974428, + 255.9645650908351, + 254.68760542571545, + 254.32376377284527, + 254.57797665148973, + 273.2069417834282, + 256.5606730058789, + 255.74724934995174, + 258.0512026324868, + 257.80391693115234, + 257.07798171788454, + 258.1150019541383, + 257.2710206732154, + 256.66352175176144, + 256.6118575632572, + 261.3121774047613, + 256.433580070734, + 256.5372521057725 + ], + "p50_ms": 256.5489625558257, + "p95_ms": 270.3398894518614, + "requests_per_second_serial": 3.873880812158602, + "peak_allocated_bytes": 9501146624, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 234.04904454946518, + 233.89310389757156, + 235.21518427878618, + 236.8757575750351, + 235.20058393478394, + 234.04523730278015, + 234.86464750021696, + 233.93372166901827, + 233.30442421138287, + 236.62311770021915, + 239.36074413359165, + 233.5211792960763, + 233.58670342713594, + 232.77552518993616, + 238.69694955646992, + 240.4197221621871, + 233.54285210371017, + 235.94586364924908, + 234.9817594513297, + 233.15637651830912, + 233.13818406313658, + 238.3321737870574, + 232.99847077578306, + 239.03468623757362, + 232.8707966953516, + 231.98277410119772, + 231.74255155026913, + 231.8384423851967, + 274.9558351933956, + 232.54162538796663, + 232.11205657571554, + 232.0533785969019, + 232.24843572825193, + 258.6780618876219, + 232.10884351283312, + 232.49470628798008, + 232.36824292689562, + 233.5412772372365, + 233.83094370365143, + 236.5080527961254, + 234.70876459032297, + 234.51872915029526, + 236.03545501828194, + 235.50415970385075, + 234.15289726108313, + 234.50167756527662, + 235.87821517139673, + 234.58449728786945, + 234.2448327690363, + 234.04456861317158 + ], + "p50_ms": 234.04714092612267, + "p95_ms": 240.4197221621871, + "requests_per_second_serial": 4.241765054515977, + "peak_allocated_bytes": 9490196992, + "peak_reserved_bytes": 10567548928 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 266.6763085871935, + 282.1172457188368, + 255.95649238675833, + 255.84823731333017, + 261.4229032769799, + 262.4343875795603, + 255.40145579725504, + 255.5707572028041, + 255.79105783253908, + 256.13384414464235, + 256.09457958489656, + 255.35377021878958, + 255.53777255117893, + 255.46501018106937, + 261.50016114115715, + 255.22081647068262, + 255.46129420399666, + 254.9853539094329, + 255.052893422544, + 258.45630932599306, + 254.5498050749302, + 254.61953971534967, + 254.42483834922314, + 255.29901031404734, + 254.971195012331, + 254.46930155158043, + 254.57001943141222, + 255.12843765318394, + 254.96665388345718, + 254.49110101908445, + 255.423316732049, + 254.7198822721839, + 263.05447332561016, + 271.146971732378, + 270.3194376081228, + 271.71845454722643, + 272.0577297732234, + 266.07226207852364, + 263.8669880107045, + 266.83797780424356, + 268.3623507618904, + 273.7486232072115, + 266.04067254811525, + 269.53721325844526, + 262.7526903524995, + 264.5670371130109, + 271.5129582211375, + 268.94333586096764, + 267.94339530169964, + 274.9141976237297 + ], + "p50_ms": 256.11421186476946, + "p95_ms": 273.7486232072115, + "requests_per_second_serial": 3.828041168719352, + "peak_allocated_bytes": 9501146624, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 245.85792049765587, + 237.36293241381645, + 234.23614911735058, + 243.53731703013182, + 241.77672527730465, + 239.24679029732943, + 234.17571280151606, + 234.2020394280553, + 234.45865139365196, + 236.8701370432973, + 236.76674161106348, + 234.04407501220703, + 233.7786639109254, + 232.74867422878742, + 233.75744838267565, + 233.1016631796956, + 233.0639660358429, + 232.92938712984324, + 232.57454670965672, + 233.48942305892706, + 233.17550402134657, + 233.39741211384535, + 232.81284421682358, + 236.7851957678795, + 233.38438849896193, + 233.25624596327543, + 232.54687525331974, + 233.15281607210636, + 239.3164411187172, + 233.17595198750496, + 236.0040880739689, + 232.71591030061245, + 232.92774707078934, + 240.47624692320824, + 240.89319445192814, + 238.2912216708064, + 240.22121541202068, + 250.9809546172619, + 251.21663324534893, + 240.83991535007954, + 250.62958803027868, + 249.09545946866274, + 247.81436007469893, + 242.04173870384693, + 247.55041021853685, + 257.43584241718054, + 249.34473540633917, + 239.91576861590147, + 249.96621254831553, + 249.81670640408993 + ], + "p50_ms": 236.77596868947148, + "p95_ms": 250.9809546172619, + "requests_per_second_serial": 4.185094828959167, + "peak_allocated_bytes": 9490196992, + "peak_reserved_bytes": 10567548928 + } + } + ] + }, + { + "id": "320x240-long-q2", + "size": [ + 320, + 240 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 2, + "status": "complete", + "fixture_sha256": "f540066a2fa4668efd2bcc56751f778e149db48f2491411ef5775b13b23d858b", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 2, + "language": 2, + "image_preprocess": 2 + }, + "reuse_counts": { + "vision": 1, + "language": 2, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 614, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "7dcdd73c6c7ed152963408f5d27174d01a49402bb537d819a68d59588a53984e" + }, + "position_ids": { + "shape": [ + 3, + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "8a75647b9a14785031d9b56d339545518f2603ae1b16f65e959f3d953d61ef68" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 614, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "7dcdd73c6c7ed152963408f5d27174d01a49402bb537d819a68d59588a53984e" + }, + "position_ids": { + "shape": [ + 3, + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "8a75647b9a14785031d9b56d339545518f2603ae1b16f65e959f3d953d61ef68" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9926069974899292, + "cancel": 0.0007049240521155298, + "wait": 0.006688133347779512 + }, + "confidence": 0.9581546345308546 + }, + "q2": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9926069974899292, + "cancel": 0.0007049240521155298, + "wait": 0.006688133347779512 + }, + "confidence": 0.9581546345308546 + } + }, + "usage": { + "input_tokens": 1228, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 273.2240417972207, + 293.1792223826051, + 280.67315835505724, + 282.30116702616215, + 286.92482970654964, + 291.18257854133844, + 275.36886278539896, + 279.87820096313953, + 282.65371453016996, + 292.7350392565131, + 285.21214332431555, + 283.41590240597725, + 273.76491855829954, + 279.98640295118093, + 276.5976479277015, + 286.10497806221247, + 329.01374250650406, + 292.9721334949136, + 290.8814437687397, + 289.3884601071477, + 284.7041692584753, + 283.17116666585207, + 281.96704387664795, + 284.63349398225546, + 300.77064502984285, + 293.29501930624247, + 286.18300426751375, + 284.56591069698334, + 280.5988909676671, + 294.88546028733253, + 301.32232047617435, + 282.6897166669369, + 347.74858597666025, + 302.61875316500664, + 286.1360078677535, + 283.4181021898985, + 287.6549158245325, + 311.40250246971846, + 291.85597598552704, + 348.9285474643111, + 285.9812015667558, + 296.8321042135358, + 287.4700967222452, + 274.5996154844761, + 272.9426743462682, + 294.91378646343946, + 286.8377212435007, + 283.53776782751083, + 287.6596553251147, + 285.8959473669529 + ], + "p50_ms": 286.120492964983, + "p95_ms": 329.01374250650406, + "requests_per_second_serial": 3.448114302115299, + "peak_allocated_bytes": 9589741056, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 253.42093408107758, + 261.38890255242586, + 258.26529785990715, + 262.67809327691793, + 260.72055380791426, + 311.3451134413481, + 258.90046171844006, + 263.9110116288066, + 265.73689840734005, + 256.8827662616968, + 251.39076448976994, + 261.1108860000968, + 258.59688501805067, + 260.78926399350166, + 252.37426348030567, + 257.81158823519945, + 277.2686779499054, + 264.85415920615196, + 263.76078464090824, + 271.1834982037544, + 260.03822684288025, + 261.2428432330489, + 252.7995714917779, + 262.8845442086458, + 269.3584868684411, + 266.07673335820436, + 260.95204055309296, + 259.81014501303434, + 262.30514980852604, + 267.95314345508814, + 258.23742244392633, + 265.8325182273984, + 264.17660992592573, + 265.2099318802357, + 263.98781035095453, + 261.47779542952776, + 262.66342774033546, + 266.6294826194644, + 258.8615594431758, + 258.09269212186337, + 259.87544283270836, + 262.12441455572844, + 272.06105552613735, + 255.2903462201357, + 254.17070370167494, + 260.38235891610384, + 259.2000784352422, + 258.5648884996772, + 267.3512911424041, + 259.30687692016363 + ], + "p50_ms": 261.17686461657286, + "p95_ms": 272.06105552613735, + "requests_per_second_serial": 3.80827371037766, + "peak_allocated_bytes": 9580157440, + "peak_reserved_bytes": 10567548928 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 291.7824862524867, + 337.47402485460043, + 346.20583802461624, + 349.2424376308918, + 284.1581692919135, + 304.56826090812683, + 283.0762453377247, + 282.4613396078348, + 283.6955226957798, + 274.22169130295515, + 280.2423182874918, + 281.63111954927444, + 286.2814851105213, + 288.7921445071697, + 287.08597645163536, + 289.381917566061, + 271.0367329418659, + 270.04051208496094, + 269.83149349689484, + 271.60860132426023, + 270.520425401628, + 270.15630062669516, + 269.71595268696547, + 268.88822577893734, + 270.8864836022258, + 270.0579008087516, + 269.50417552143335, + 269.26608104258776, + 274.79082997888327, + 272.76191394776106, + 271.6011954471469, + 271.31793182343245, + 270.72630170732737, + 270.23869659751654, + 270.075187087059, + 271.13029919564724, + 270.05553618073463, + 271.73647191375494, + 270.22639382630587, + 269.96961422264576, + 269.8411149904132, + 287.6087408512831, + 275.8444044739008, + 270.49389481544495, + 272.7576429024339, + 273.78092519938946, + 271.2009446695447, + 271.44763991236687, + 271.3543251156807, + 270.7050060853362 + ], + "p50_ms": 271.5244176797569, + "p95_ms": 337.47402485460043, + "requests_per_second_serial": 3.5761596074265434, + "peak_allocated_bytes": 9589741056, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 273.1052367016673, + 329.2175317183137, + 312.38633673638105, + 316.29212759435177, + 263.51179368793964, + 256.0104690492153, + 259.5829516649246, + 256.0707200318575, + 260.92157792299986, + 269.8170496150851, + 263.88969365507364, + 259.1193290427327, + 264.8943895474076, + 268.2598037645221, + 263.1319174543023, + 265.2322882786393, + 251.37307681143284, + 250.09764451533556, + 249.32505562901497, + 262.85948790609837, + 250.97848568111658, + 248.63530043512583, + 248.97181801497936, + 249.17095061391592, + 254.6547707170248, + 248.90216998755932, + 248.86513128876686, + 250.81741344183683, + 251.15107744932175, + 251.05518475174904, + 250.73589198291302, + 251.33285205811262, + 251.29684526473284, + 248.7279763445258, + 248.94479475915432, + 249.31572750210762, + 249.024648219347, + 249.3273112922907, + 249.67446736991405, + 248.74589871615171, + 249.13551099598408, + 265.52211213856936, + 256.6083036363125, + 249.96049515902996, + 250.44397544115782, + 255.02821430563927, + 251.13481655716896, + 251.68490130454302, + 251.08804553747177, + 256.37373700737953 + ], + "p50_ms": 251.31484866142273, + "p95_ms": 312.38633673638105, + "requests_per_second_serial": 3.866256204599989, + "peak_allocated_bytes": 9580157440, + "peak_reserved_bytes": 10567548928 + } + } + ] + }, + { + "id": "320x240-long-q8", + "size": [ + 320, + 240 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 8, + "status": "complete", + "fixture_sha256": "4594ca192ccba71269c101df00dc7c34001fea5f16195c1d3091b59234e54131", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 8, + "language": 8, + "image_preprocess": 8 + }, + "reuse_counts": { + "vision": 1, + "language": 8, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "be6eb9c56b959ab46ac2bf94ab12fc87b19a01e77cfdc522b7e2ab470707d9c9" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "38b7306c2508789cd292bcdefe5ab3c334ad01030af596fd977a1decedf1cfdd" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 614, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "7dcdd73c6c7ed152963408f5d27174d01a49402bb537d819a68d59588a53984e" + }, + "position_ids": { + "shape": [ + 3, + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "8a75647b9a14785031d9b56d339545518f2603ae1b16f65e959f3d953d61ef68" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 614, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "7dcdd73c6c7ed152963408f5d27174d01a49402bb537d819a68d59588a53984e" + }, + "position_ids": { + "shape": [ + 3, + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "8a75647b9a14785031d9b56d339545518f2603ae1b16f65e959f3d953d61ef68" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 614, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "7dcdd73c6c7ed152963408f5d27174d01a49402bb537d819a68d59588a53984e" + }, + "position_ids": { + "shape": [ + 3, + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "8a75647b9a14785031d9b56d339545518f2603ae1b16f65e959f3d953d61ef68" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 614, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "7dcdd73c6c7ed152963408f5d27174d01a49402bb537d819a68d59588a53984e" + }, + "position_ids": { + "shape": [ + 3, + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "8a75647b9a14785031d9b56d339545518f2603ae1b16f65e959f3d953d61ef68" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 614, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "7dcdd73c6c7ed152963408f5d27174d01a49402bb537d819a68d59588a53984e" + }, + "position_ids": { + "shape": [ + 3, + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "8a75647b9a14785031d9b56d339545518f2603ae1b16f65e959f3d953d61ef68" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 614, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "7dcdd73c6c7ed152963408f5d27174d01a49402bb537d819a68d59588a53984e" + }, + "position_ids": { + "shape": [ + 3, + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "8a75647b9a14785031d9b56d339545518f2603ae1b16f65e959f3d953d61ef68" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 614, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "7dcdd73c6c7ed152963408f5d27174d01a49402bb537d819a68d59588a53984e" + }, + "position_ids": { + "shape": [ + 3, + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "8a75647b9a14785031d9b56d339545518f2603ae1b16f65e959f3d953d61ef68" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 614, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "7dcdd73c6c7ed152963408f5d27174d01a49402bb537d819a68d59588a53984e" + }, + "position_ids": { + "shape": [ + 3, + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "8a75647b9a14785031d9b56d339545518f2603ae1b16f65e959f3d953d61ef68" + }, + "attention_mask": { + "shape": [ + 1, + 614 + ], + "dtype": "torch.int64", + "sha256": "e3b5b8bbe45f522d2a6e57817aad038d1ee53a7522409adea00aabab542def20" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9926069974899292, + "cancel": 0.0007049240521155298, + "wait": 0.006688133347779512 + }, + "confidence": 0.9581546345308546 + }, + "q2": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9926069974899292, + "cancel": 0.0007049240521155298, + "wait": 0.006688133347779512 + }, + "confidence": 0.9581546345308546 + }, + "q3": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9926069974899292, + "cancel": 0.0007049240521155298, + "wait": 0.006688133347779512 + }, + "confidence": 0.9581546345308546 + }, + "q4": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9926069974899292, + "cancel": 0.0007049240521155298, + "wait": 0.006688133347779512 + }, + "confidence": 0.9581546345308546 + }, + "q5": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9926069974899292, + "cancel": 0.0007049240521155298, + "wait": 0.006688133347779512 + }, + "confidence": 0.9581546345308546 + }, + "q6": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9926069974899292, + "cancel": 0.0007049240521155298, + "wait": 0.006688133347779512 + }, + "confidence": 0.9581546345308546 + }, + "q7": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9926069974899292, + "cancel": 0.0007049240521155298, + "wait": 0.006688133347779512 + }, + "confidence": 0.9581546345308546 + }, + "q8": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9926069974899292, + "cancel": 0.0007049240521155298, + "wait": 0.006688133347779512 + }, + "confidence": 0.9581546345308546 + } + }, + "usage": { + "input_tokens": 4912, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 1161.0527355223894, + 1078.4695222973824, + 1112.120863981545, + 1110.810026526451, + 1105.0785882398486, + 1108.9493418112397, + 1075.0986887142062, + 1142.6582802087069, + 1121.477578766644, + 1135.0744692608714, + 1148.7842481583357, + 1149.2322077974677, + 1095.8560872823, + 1129.6670101583004, + 1338.7861419469118, + 1166.6287872940302, + 1154.7811422497034, + 1163.1284700706601, + 1108.6054788902402, + 1176.3389958068728, + 1105.3583091124892, + 1185.3904379531741, + 1203.3862238749862, + 1195.7928482443094, + 1236.5937810391188, + 1175.4700066521764, + 1210.452183149755, + 1189.2724027857184, + 1170.6027872860432, + 1213.8068918138742, + 1221.764069981873, + 1167.6213089376688, + 1223.968000151217, + 1219.6971774101257, + 1186.7921380326152, + 1136.1607564613223, + 1198.091208934784, + 1139.526691287756, + 1194.098754785955, + 1157.5191216543317, + 1203.8132529705763, + 1232.3813270777464, + 1181.4937628805637, + 1197.0602050423622, + 1123.340893536806, + 1089.6117221564054, + 1087.3528635129333, + 1121.556549333036, + 1094.1838454455137, + 1114.4770290702581 + ], + "p50_ms": 1159.2859285883605, + "p95_ms": 1232.3813270777464, + "requests_per_second_serial": 0.8626752891759537, + "peak_allocated_bytes": 9597957120, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 934.5629392191768, + 943.4460857883096, + 938.9024935662746, + 946.0221249610186, + 933.3386123180389, + 962.6866159960628, + 1090.452623553574, + 974.9271841719747, + 942.4844896420836, + 931.5847745165229, + 936.4657904952765, + 930.3967794403434, + 942.4269795417786, + 931.7942652851343, + 986.6341687738895, + 978.6175535991788, + 962.6414394006133, + 961.0915556550026, + 956.193164922297, + 964.9704154580832, + 957.166988402605, + 963.9612631872296, + 1011.0296690836549, + 1007.9130018129945, + 1001.6670050099492, + 1011.434598825872, + 998.3746726065874, + 1005.2949413657188, + 998.9868057891726, + 1007.2943000122905, + 1086.9847759604454, + 1192.2846613451838, + 984.3330765143037, + 989.0363281592727, + 969.6861114352942, + 991.5175624191761, + 971.6514050960541, + 999.6265908703208, + 958.9883536100388, + 975.6643734872341, + 980.5441750213504, + 1005.7712271809578, + 979.1423277929425, + 981.5357327461243, + 943.7436163425446, + 934.596267528832, + 942.8946152329445, + 942.8757252171636, + 942.8220158442855, + 936.0642293468118 + ], + "p50_ms": 967.3282634466887, + "p95_ms": 1086.9847759604454, + "requests_per_second_serial": 1.0241174230728487, + "peak_allocated_bytes": 9580157440, + "peak_reserved_bytes": 10567548928 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 1171.4343186467886, + 1111.492712981999, + 1152.8197238221765, + 1106.8557668477297, + 1110.8583062887192, + 1109.3622064217925, + 1107.4363142251968, + 1105.7728407904506, + 1162.3560320585966, + 1160.9629886224866, + 1083.8540038093925, + 1094.3571962416172, + 1115.823826752603, + 1094.758684746921, + 1110.3956867009401, + 1109.1462364420295, + 1150.6291525438428, + 1176.6145704314113, + 1158.4898624569178, + 1106.9344449788332, + 1093.1924292817712, + 1107.6529873535037, + 1138.3104817941785, + 1090.5282124876976, + 1109.994146041572, + 1175.913792103529, + 1123.148719780147, + 1078.472108580172, + 1124.2377972230315, + 1091.6842464357615, + 1111.0801426693797, + 1112.7843661233783, + 1217.462720349431, + 1200.208348222077, + 1194.7128837928176, + 1146.0717217996716, + 1221.8726370483637, + 1196.9217723235488, + 1193.7621990218759, + 1137.229879386723, + 1201.2821612879634, + 1245.813668705523, + 1169.790274463594, + 1204.6434944495559, + 1102.7435651049018, + 1236.3033443689346, + 1147.1592485904694, + 1183.7101355195045, + 1347.788130864501, + 1201.9723132252693 + ], + "p50_ms": 1137.7701805904508, + "p95_ms": 1236.3033443689346, + "requests_per_second_serial": 0.8709769148881046, + "peak_allocated_bytes": 9597957120, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 945.4729408025742, + 954.4964488595724, + 960.6903279200196, + 937.6669190824032, + 942.5391210243106, + 939.0086270868778, + 945.4485615715384, + 941.9753309339285, + 936.6565924137831, + 981.8817507475615, + 935.2523796260357, + 943.6439527198672, + 937.9328852519393, + 942.5871018320322, + 940.0803046301007, + 943.5039395466447, + 949.7259091585875, + 971.1013827472925, + 951.3387195765972, + 940.0509661063552, + 947.068770416081, + 935.3018971160054, + 942.5736889243126, + 953.0568635091186, + 960.0903261452913, + 946.3003622367978, + 934.1185241937637, + 946.061484515667, + 935.7309490442276, + 936.8590228259563, + 948.2384286820889, + 943.8380124047399, + 990.5594671145082, + 983.4806388244033, + 991.8931778520346, + 971.3239604607224, + 987.8739947453141, + 978.4619612619281, + 995.9152583032846, + 987.3458491638303, + 995.0621007010341, + 994.5861231535673, + 985.2599771693349, + 986.1040292307734, + 984.7394255921245, + 986.4413542672992, + 971.2578793987632, + 969.8752807453275, + 986.5883700549603, + 982.2126440703869 + ], + "p50_ms": 950.5323143675923, + "p95_ms": 994.5861231535673, + "requests_per_second_serial": 1.0416824224657062, + "peak_allocated_bytes": 9580157440, + "peak_reserved_bytes": 10567548928 + } + } + ] + }, + { + "id": "640x480-long-q1", + "size": [ + 640, + 480 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 1, + "status": "complete", + "fixture_sha256": "02daa6d5693dee5fb34786990084ae368efb181c5adbabde33392dbad2761b8b", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 834, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0f4933b9cd8920b9f60b0202f44a126bf595fcb1618c173f630cb6d23d49a0c6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "290e2e206a836ca5c2d731a28a73a88ddf11e4b46f3bb9df108c6761c783ef08" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9877169728279114, + "cancel": 0.0013104835525155067, + "wait": 0.010972544550895691 + }, + "confidence": 0.9359032375170542 + } + }, + "usage": { + "input_tokens": 834, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 203.40558141469955, + 191.6660526767373, + 190.4124589636922, + 200.0699397176504, + 192.9209055379033, + 158.6532173678279, + 161.97689436376095, + 157.6563697308302, + 159.30588264018297, + 158.6311198771, + 168.96773595362902, + 160.74982937425375, + 159.08451285213232, + 159.51847936958075, + 163.6297134682536, + 163.33606652915478, + 159.54237710684538, + 159.2717319726944, + 161.6352340206504, + 161.50671057403088, + 160.51754727959633, + 159.48686841875315, + 160.8953606337309, + 158.7133565917611, + 154.75154481828213, + 154.64212372899055, + 154.44438066333532, + 154.42283544689417, + 154.26943358033895, + 154.67341244220734, + 154.55378033220768, + 159.10291112959385, + 154.84163165092468, + 154.54712603241205, + 154.54680752009153, + 154.49639316648245, + 154.53592035919428, + 154.7847669571638, + 159.11369305104017, + 154.71164416521788, + 154.5457700267434, + 154.68074567615986, + 154.41423188894987, + 155.91129753738642, + 155.5815190076828, + 154.55045085400343, + 154.45371996611357, + 154.26645521074533, + 154.39508575946093, + 154.48086708784103 + ], + "p50_ms": 158.1437448039651, + "p95_ms": 192.9209055379033, + "requests_per_second_serial": 6.202494709631173, + "peak_allocated_bytes": 9701124096, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 193.22655349969864, + 192.8537031635642, + 194.84782870858908, + 196.14216219633818, + 169.93074864149094, + 162.671678699553, + 172.42087423801422, + 155.91660048812628, + 163.01901638507843, + 162.14296128600836, + 160.64440552145243, + 162.44054213166237, + 155.48132173717022, + 157.67555963248014, + 162.61489782482386, + 159.96527206152678, + 172.03555721789598, + 165.92882573604584, + 163.07036485522985, + 158.61642267554998, + 162.40734327584505, + 161.09257005155087, + 164.03834614902735, + 158.42059720307589, + 155.05480393767357, + 154.57527991384268, + 154.54360749572515, + 154.44040205329657, + 154.5228585600853, + 154.46144342422485, + 154.68809381127357, + 158.107103779912, + 154.60451412945986, + 154.7136940062046, + 154.5215742662549, + 154.53292708843946, + 154.9993585795164, + 154.8624373972416, + 154.92074470967054, + 154.8298355191946, + 154.77005392313004, + 154.5181581750512, + 156.52378741651773, + 156.34274762123823, + 154.93024606257677, + 158.59974268823862, + 154.5647755265236, + 154.35743611305952, + 154.44129053503275, + 154.36132159084082 + ], + "p50_ms": 156.43326751887798, + "p95_ms": 193.22655349969864, + "requests_per_second_serial": 6.203941633548921, + "peak_allocated_bytes": 9701124096, + "peak_reserved_bytes": 10567548928 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 154.48706783354282, + 154.41918093711138, + 209.78995319455862, + 184.72489528357983, + 183.4527226164937, + 183.4463020786643, + 184.4302574172616, + 184.3271218240261, + 173.22673182934523, + 155.62600083649158, + 155.4582854732871, + 171.58841900527477, + 185.0719964131713, + 185.02622563391924, + 197.90089409798384, + 193.58465261757374, + 166.07937309890985, + 157.80887100845575, + 157.24936500191689, + 157.74807147681713, + 164.07712642103434, + 166.16838611662388, + 155.42615856975317, + 155.52354790270329, + 155.31838778406382, + 155.1921246573329, + 155.35898879170418, + 155.13637848198414, + 166.4410624653101, + 155.80229088664055, + 155.6345820426941, + 155.11183347553015, + 156.68149944394827, + 155.20650148391724, + 155.54185211658478, + 155.10391350835562, + 155.23036662489176, + 155.00019025057554, + 155.29065765440464, + 155.82383051514626, + 155.26828821748495, + 155.50607535988092, + 162.57956344634295, + 155.88928293436766, + 155.11581860482693, + 155.16870003193617, + 155.23710194975138, + 155.05529660731554, + 155.67471459507942, + 155.97993601113558 + ], + "p50_ms": 155.73850274085999, + "p95_ms": 193.58465261757374, + "requests_per_second_serial": 6.100543661876064, + "peak_allocated_bytes": 9701124096, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 154.58140429109335, + 154.4125508517027, + 159.12383422255516, + 184.0822407975793, + 183.20408463478088, + 186.66419573128223, + 184.22660697251558, + 184.25224628299475, + 183.1496423110366, + 156.6336816176772, + 156.38023521751165, + 177.28108912706375, + 182.85965267568827, + 185.20790338516235, + 189.91182651370764, + 190.18680602312088, + 196.39249611645937, + 156.89648780971766, + 156.02110791951418, + 156.73543885350227, + 161.06758546084166, + 156.68721124529839, + 155.34449741244316, + 155.19669093191624, + 155.3965974599123, + 155.3036393597722, + 154.95399665087461, + 155.23723419755697, + 159.50637497007847, + 155.51378019154072, + 155.4600540548563, + 155.18292784690857, + 156.5616363659501, + 155.24879097938538, + 155.38776014000177, + 162.22398914396763, + 155.28704412281513, + 155.40288854390383, + 155.1280850544572, + 155.18429409712553, + 155.1291160285473, + 155.21008521318436, + 155.2532659843564, + 155.39870597422123, + 155.18738888204098, + 155.1455156877637, + 155.13333678245544, + 155.76632879674435, + 156.8406354635954, + 171.32682725787163 + ], + "p50_ms": 155.89371835812926, + "p95_ms": 189.91182651370764, + "requests_per_second_serial": 6.11705362669677, + "peak_allocated_bytes": 9701124096, + "peak_reserved_bytes": 10567548928 + } + } + ] + }, + { + "id": "640x480-long-q8", + "size": [ + 640, + 480 + ], + "goal": "long", + "goal_repetitions": 64, + "questions": 8, + "status": "complete", + "fixture_sha256": "458daec297c15711744c3912daaf55c4e63a27989c95f050440c6559a457dab2", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 8, + "language": 8, + "image_preprocess": 8 + }, + "reuse_counts": { + "vision": 1, + "language": 8, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "cdc2c411c85290df7546859746717a9602677f6e24779c0c59d67e705ecfb5f9" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "b4192b0cb3c93b9bdb60144e1bf803523f7eb7d6bc6d9442d7d9ae9ba65fc357" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 834, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0f4933b9cd8920b9f60b0202f44a126bf595fcb1618c173f630cb6d23d49a0c6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "290e2e206a836ca5c2d731a28a73a88ddf11e4b46f3bb9df108c6761c783ef08" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 834, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0f4933b9cd8920b9f60b0202f44a126bf595fcb1618c173f630cb6d23d49a0c6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "290e2e206a836ca5c2d731a28a73a88ddf11e4b46f3bb9df108c6761c783ef08" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 834, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0f4933b9cd8920b9f60b0202f44a126bf595fcb1618c173f630cb6d23d49a0c6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "290e2e206a836ca5c2d731a28a73a88ddf11e4b46f3bb9df108c6761c783ef08" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 834, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0f4933b9cd8920b9f60b0202f44a126bf595fcb1618c173f630cb6d23d49a0c6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "290e2e206a836ca5c2d731a28a73a88ddf11e4b46f3bb9df108c6761c783ef08" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 834, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0f4933b9cd8920b9f60b0202f44a126bf595fcb1618c173f630cb6d23d49a0c6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "290e2e206a836ca5c2d731a28a73a88ddf11e4b46f3bb9df108c6761c783ef08" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 834, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0f4933b9cd8920b9f60b0202f44a126bf595fcb1618c173f630cb6d23d49a0c6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "290e2e206a836ca5c2d731a28a73a88ddf11e4b46f3bb9df108c6761c783ef08" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 834, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0f4933b9cd8920b9f60b0202f44a126bf595fcb1618c173f630cb6d23d49a0c6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "290e2e206a836ca5c2d731a28a73a88ddf11e4b46f3bb9df108c6761c783ef08" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 834, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0f4933b9cd8920b9f60b0202f44a126bf595fcb1618c173f630cb6d23d49a0c6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "290e2e206a836ca5c2d731a28a73a88ddf11e4b46f3bb9df108c6761c783ef08" + }, + "attention_mask": { + "shape": [ + 1, + 834 + ], + "dtype": "torch.int64", + "sha256": "71d045030e8dffc3841c85354aad786462824dbe1fe6f8db1fdd02f74c8283c8" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9877169728279114, + "cancel": 0.0013104835525155067, + "wait": 0.010972544550895691 + }, + "confidence": 0.9359032375170542 + }, + "q2": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9877169728279114, + "cancel": 0.0013104835525155067, + "wait": 0.010972544550895691 + }, + "confidence": 0.9359032375170542 + }, + "q3": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9877169728279114, + "cancel": 0.0013104835525155067, + "wait": 0.010972544550895691 + }, + "confidence": 0.9359032375170542 + }, + "q4": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9877169728279114, + "cancel": 0.0013104835525155067, + "wait": 0.010972544550895691 + }, + "confidence": 0.9359032375170542 + }, + "q5": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9877169728279114, + "cancel": 0.0013104835525155067, + "wait": 0.010972544550895691 + }, + "confidence": 0.9359032375170542 + }, + "q6": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9877169728279114, + "cancel": 0.0013104835525155067, + "wait": 0.010972544550895691 + }, + "confidence": 0.9359032375170542 + }, + "q7": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9877169728279114, + "cancel": 0.0013104835525155067, + "wait": 0.010972544550895691 + }, + "confidence": 0.9359032375170542 + }, + "q8": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9877169728279114, + "cancel": 0.0013104835525155067, + "wait": 0.010972544550895691 + }, + "confidence": 0.9359032375170542 + } + }, + "usage": { + "input_tokens": 6672, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 1303.046327084303, + 1304.9061074852943, + 1317.903962917626, + 1275.5360770970583, + 1266.4432534947991, + 1292.5313338637352, + 1298.959924839437, + 1319.8650497943163, + 1309.406672604382, + 1293.51791087538, + 1330.965400673449, + 1260.689185000956, + 1387.8712048754096, + 1310.2428475394845, + 1321.8687027692795, + 1314.9388413876295, + 1425.5338031798601, + 1357.4213841930032, + 1392.806451767683, + 1354.8069596290588, + 1399.5617665350437, + 1427.5345541536808, + 1324.5153911411762, + 1359.110509045422, + 1372.2106106579304, + 1338.1808074191213, + 1404.0166782215238, + 1412.751137278974, + 1397.3544230684638, + 1366.5229678153992, + 1638.1487464532256, + 1367.815705947578, + 1474.1062689572573, + 1423.9457035437226, + 1525.9363381192088, + 1289.7695153951645, + 1308.6072215810418, + 1312.040077522397, + 1362.4960873275995, + 1317.1907281503081, + 1302.0233334973454, + 1298.0832951143384, + 1336.9193095713854, + 1243.1752514094114, + 1306.4478868618608, + 1305.9204081073403, + 1308.3815583959222, + 1296.843035146594, + 1318.4713311493397, + 1256.9110384210944 + ], + "p50_ms": 1319.168190471828, + "p95_ms": 1474.1062689572573, + "requests_per_second_serial": 0.7436685573831033, + "peak_allocated_bytes": 9753160192, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 1095.1229901984334, + 1097.7895399555564, + 1143.1798823177814, + 1098.2722137123346, + 1117.162705399096, + 1085.5144057422876, + 1091.5607633069158, + 1083.2254141569138, + 1105.8624098077416, + 1115.2320615947247, + 1096.615788526833, + 1092.7033368498087, + 1096.0222510620952, + 1083.1849537789822, + 1102.9768539592624, + 1088.6569283902645, + 1134.986151009798, + 1134.7887627780437, + 1168.7192376703024, + 1147.2449926659465, + 1150.786180049181, + 1127.0000590011477, + 1144.132168032229, + 1120.762794278562, + 1144.42946203053, + 1123.7018378451467, + 1143.4040367603302, + 1175.5677200853825, + 1137.7556966617703, + 1136.012609116733, + 1201.8244750797749, + 1149.3785502389073, + 1165.296665392816, + 1194.6105295792222, + 1220.3874066472054, + 1104.8054220154881, + 1112.2534265741706, + 1097.0955369994044, + 1101.1626766994596, + 1085.831193253398, + 1196.357729844749, + 1103.4785341471434, + 1096.933209337294, + 1115.812069736421, + 1096.1970435455441, + 1089.175689034164, + 1101.0129358619452, + 1128.9753634482622, + 1109.3592699617147, + 1090.403682552278 + ], + "p50_ms": 1113.7427440844476, + "p95_ms": 1196.357729844749, + "requests_per_second_serial": 0.8905873281138489, + "peak_allocated_bytes": 9699164160, + "peak_reserved_bytes": 10567548928 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 1290.5770232900977, + 1314.5581288263202, + 1293.5068709775805, + 1315.3236908838153, + 1266.9161623343825, + 1309.2717742547393, + 1294.3538054823875, + 1302.6859322562814, + 1308.3347426727414, + 1300.438156351447, + 1420.7997750490904, + 1290.8493001013994, + 1255.3463531658053, + 1299.4474628940225, + 1311.6888357326388, + 1342.0504303649068, + 1317.117647267878, + 1431.7992078140378, + 1443.6207115650177, + 1342.7337417379022, + 1352.072305046022, + 1455.1689643412828, + 1341.4458129554987, + 1373.2330854982138, + 1310.1906897500157, + 1330.421763472259, + 1322.0648607239127, + 1376.156834885478, + 1342.0018488541245, + 1310.183267109096, + 1385.6508638709784, + 1409.1549701988697, + 1573.6639061942697, + 1446.670119650662, + 1337.5732554122806, + 1438.1139297038317, + 1308.6350979283452, + 1386.5732252597809, + 1361.7720259353518, + 1240.3829954564571, + 1304.5049058273435, + 1306.8536631762981, + 1296.588539145887, + 1333.6001578718424, + 1245.827790349722, + 1302.411218173802, + 1303.777763620019, + 1296.853268519044, + 1337.2205710038543, + 1371.109682135284 + ], + "p50_ms": 1316.2206690758467, + "p95_ms": 1446.670119650662, + "requests_per_second_serial": 0.7468115203072392, + "peak_allocated_bytes": 9753160192, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 1097.9468077421188, + 1103.7675822153687, + 1088.1994348019361, + 1105.7174429297447, + 1122.1893420442939, + 1089.1292793676257, + 1093.117045238614, + 1098.1325497850776, + 1096.0156675428152, + 1090.6496839597821, + 1100.0188933685422, + 1138.776927255094, + 1096.609272994101, + 1094.767582602799, + 1088.3857477456331, + 1095.6463096663356, + 1132.4096573516726, + 1138.9795495197177, + 1135.7789505273104, + 1119.5867927744985, + 1125.6426721811295, + 1156.3896834850311, + 1126.6624489799142, + 1156.9215254858136, + 1140.4501311481, + 1152.0756408572197, + 1122.8135749697685, + 1135.5892205610871, + 1120.5013087019324, + 1159.3634085729718, + 1152.3973233997822, + 1183.660475537181, + 1370.0660225003958, + 1136.3915679976344, + 1154.2470008134842, + 1127.3079961538315, + 1158.1805869936943, + 1099.9620174989104, + 1098.382887430489, + 1097.594067454338, + 1103.8137944415212, + 1100.5321498960257, + 1122.0497274771333, + 1104.6074572950602, + 1086.1438903957605, + 1099.574119783938, + 1087.8257537260652, + 1099.7361382469535, + 1093.4829637408257, + 1124.6404219418764 + ], + "p50_ms": 1112.6521178521216, + "p95_ms": 1159.3634085729718, + "requests_per_second_serial": 0.8909030345962821, + "peak_allocated_bytes": 9699164160, + "peak_reserved_bytes": 10567548928 + } + } + ] + }, + { + "id": "320x240-short-q8", + "size": [ + 320, + 240 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 8, + "status": "complete", + "fixture_sha256": "c18af7ee94cfe01f0a583e7f528e5e2e62f95a619278a49c6655e1e685f6f869", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 8, + "language": 8, + "image_preprocess": 8 + }, + "reuse_counts": { + "vision": 1, + "language": 8, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q2": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q3": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q4": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q5": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q6": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q7": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q8": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + } + }, + "usage": { + "input_tokens": 1888, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 879.4828057289124, + 936.8037478998303, + 931.0053130611777, + 907.6716220006347, + 897.9949811473489, + 865.4694212600589, + 882.8077921643853, + 883.4418542683125, + 882.4413847178221, + 945.0539713725448, + 901.5739597380161, + 876.1257287114859, + 898.9222962409258, + 901.0768169537187, + 887.6990349963307, + 868.492397479713, + 892.1107798814774, + 945.1517658308148, + 887.5965541228652, + 864.0450155362487, + 882.3732575401664, + 892.736810259521, + 920.9031220525503, + 926.3662109151483, + 892.2403436154127, + 899.9697957187891, + 896.9706716015935, + 916.0552872344851, + 989.3399374559522, + 993.9709482714534, + 902.5565376505256, + 948.6957658082247, + 917.9376931861043, + 966.4086811244488, + 959.0820614248514, + 956.3285335898399, + 925.1944329589605, + 963.8343518599868, + 910.9599534422159, + 1004.4318679720163, + 975.25245975703, + 975.1834403723478, + 927.161106839776, + 968.045081011951, + 989.3534174188972, + 979.3881233781576, + 916.5833694860339, + 978.0392609536648, + 895.4526744782925, + 912.90467325598 + ], + "p50_ms": 914.4799802452326, + "p95_ms": 989.3534174188972, + "requests_per_second_serial": 1.0841592232814463, + "peak_allocated_bytes": 9384204800, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 718.6317080631852, + 741.3708884268999, + 720.0764482840896, + 742.4209658056498, + 718.6271948739886, + 731.983738951385, + 718.6514800414443, + 718.6804506927729, + 725.3336431458592, + 726.0458106175065, + 720.0602144002914, + 722.7052804082632, + 731.1055641621351, + 748.7291600555182, + 726.3613156974316, + 724.323358386755, + 723.6992428079247, + 728.5928316414356, + 729.11929897964, + 723.7381348386407, + 718.8444156199694, + 718.5049559921026, + 822.5029073655605, + 746.0279315710068, + 752.4093436077237, + 747.4636761471629, + 752.1804068237543, + 759.3025676906109, + 754.9571180716157, + 755.5293217301369, + 762.5165823847055, + 759.0716062113643, + 760.1554039865732, + 771.8613790348172, + 814.4533382728696, + 752.7839867398143, + 754.8072235658765, + 764.9736860767007, + 743.3487577363849, + 757.0122452452779, + 767.6399936899543, + 761.9106490164995, + 751.3205008581281, + 771.385645493865, + 758.4807118400931, + 749.815808609128, + 757.8029297292233, + 753.1436253339052, + 739.708760753274, + 754.4511379674077 + ], + "p50_ms": 748.0964181013405, + "p95_ms": 771.8613790348172, + "requests_per_second_serial": 1.3413951774626178, + "peak_allocated_bytes": 9369593344, + "peak_reserved_bytes": 10567548928 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 871.1671745404601, + 909.1635728254914, + 865.8395586535335, + 885.2458316832781, + 869.4190885871649, + 882.9294741153717, + 865.8026568591595, + 905.1210172474384, + 973.9015270024538, + 869.9155291542411, + 869.9848698452115, + 927.912874147296, + 934.0240871533751, + 894.407787360251, + 952.355656772852, + 899.4423802942038, + 1068.4273038059473, + 943.0278949439526, + 895.6727841868997, + 877.8563849627972, + 934.0531239286065, + 894.3251753225923, + 871.8145275488496, + 886.348151601851, + 872.9809550568461, + 883.7011316791177, + 862.6688718795776, + 885.7948295772076, + 907.3981707915664, + 863.0821602419019, + 903.6262659355998, + 896.6898377984762, + 863.9686740934849, + 904.898171313107, + 917.0623077079654, + 907.0943323895335, + 864.4600203260779, + 891.6385574266315, + 936.9272878393531, + 882.5277872383595, + 920.6092413514853, + 899.8522534966469, + 873.8068835809827, + 885.00533439219, + 871.2870627641678, + 884.8138889297843, + 869.1925602033734, + 886.995998211205, + 962.4329898506403, + 955.7311022654176 + ], + "p50_ms": 889.3172778189182, + "p95_ms": 962.4329898506403, + "requests_per_second_serial": 1.1110517288803625, + "peak_allocated_bytes": 9384204800, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 762.284635566175, + 731.0873912647367, + 720.0166890397668, + 721.6444332152605, + 721.4989066123962, + 728.6103134974837, + 723.4763968735933, + 727.4767123162746, + 718.8657559454441, + 735.6687132269144, + 777.2315153852105, + 720.9797753021121, + 725.4135180264711, + 723.6401746049523, + 737.6958588138223, + 719.0106529742479, + 718.442628160119, + 725.5352092906833, + 839.2955781891942, + 739.8536754772067, + 720.4661006107926, + 719.0637327730656, + 724.7379720211029, + 719.5942308753729, + 724.8514862731099, + 725.4037484526634, + 720.0306821614504, + 718.6409700661898, + 724.5839647948742, + 741.8734896928072, + 732.9205311834812, + 735.418695025146, + 718.6328321695328, + 718.7880435958505, + 739.4772972911596, + 727.6977328583598, + 717.5215696915984, + 732.7557159587741, + 748.7495448440313, + 749.6152929961681, + 725.4490442574024, + 717.9192760959268, + 718.4320809319615, + 722.0996683463454, + 724.5263177901506, + 720.1499864459038, + 719.9656879529357, + 721.6549525037408, + 747.3526885733008, + 757.4810972437263 + ], + "p50_ms": 724.6609684079885, + "p95_ms": 762.284635566175, + "requests_per_second_serial": 1.3678549663595208, + "peak_allocated_bytes": 9369593344, + "peak_reserved_bytes": 10567548928 + } + } + ] + }, + { + "id": "320x240-short-q2", + "size": [ + 320, + 240 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 2, + "status": "complete", + "fixture_sha256": "d32998f61c3f875804c0161fe9eaca360d5eae5eb6e8adebde55b969ebbf666c", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 2, + "language": 2, + "image_preprocess": 2 + }, + "reuse_counts": { + "vision": 1, + "language": 2, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "q2": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + } + }, + "usage": { + "input_tokens": 472, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 222.56615944206715, + 243.6931123957038, + 227.35082264989614, + 229.8730295151472, + 228.59089635312557, + 223.01248740404844, + 232.2564162313938, + 235.50405446439981, + 220.63513938337564, + 242.4620520323515, + 260.04465855658054, + 229.64987438172102, + 232.52666275948286, + 224.35453161597252, + 227.19352319836617, + 224.76141434162855, + 236.2928530201316, + 223.17042388021946, + 223.191874101758, + 238.72344940900803, + 225.51893442869186, + 236.32609099149704, + 228.85943297296762, + 226.52544919401407, + 231.47924337536097, + 221.6997565701604, + 220.76002601534128, + 229.90550380200148, + 236.6025699302554, + 227.22791321575642, + 236.0389493405819, + 232.89318289607763, + 234.25723891705275, + 227.0555505529046, + 233.67601539939642, + 235.3629032149911, + 228.85695192962885, + 224.54097028821707, + 218.9008817076683, + 223.35000522434711, + 232.99141600728035, + 234.628195874393, + 235.78466102480888, + 224.92071706801653, + 225.34581646323204, + 223.92176557332277, + 230.19092995673418, + 226.68035421520472, + 232.48780611902475, + 228.4300271421671 + ], + "p50_ms": 228.85819245129824, + "p95_ms": 242.4620520323515, + "requests_per_second_serial": 4.347420569187814, + "peak_allocated_bytes": 9371713024, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 206.43004961311817, + 205.43691888451576, + 206.27801027148962, + 205.5362183600664, + 202.47573964297771, + 203.27974203974009, + 226.7464753240347, + 205.9482829645276, + 209.9381322041154, + 200.1191070303321, + 210.05868911743164, + 202.56338082253933, + 208.200229331851, + 201.624589972198, + 201.2749807909131, + 210.36715619266033, + 211.20050828903913, + 207.612837664783, + 203.94231006503105, + 203.79665587097406, + 200.67408680915833, + 202.21925992518663, + 200.730730779469, + 208.63032713532448, + 205.57464007288218, + 201.02104172110558, + 210.51438245922327, + 210.79231332987547, + 197.32338935136795, + 211.37215197086334, + 200.4501298069954, + 206.43901638686657, + 208.4285467863083, + 212.01734803617, + 210.67126002162695, + 205.55331837385893, + 216.61808528006077, + 210.984923876822, + 202.73295231163502, + 210.03713738173246, + 201.37462858110666, + 200.67062508314848, + 208.73411651700735, + 211.52004972100258, + 197.8659564629197, + 211.0295109450817, + 204.73002083599567, + 213.63460831344128, + 204.9508849158883, + 203.54866702109575 + ], + "p50_ms": 205.7614615187049, + "p95_ms": 213.63460831344128, + "requests_per_second_serial": 4.843236951904444, + "peak_allocated_bytes": 9369593344, + "peak_reserved_bytes": 10567548928 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 225.14225915074348, + 229.77307345718145, + 231.9690529257059, + 234.35769136995077, + 231.78274650126696, + 227.9138807207346, + 234.1331271454692, + 235.19881069660187, + 226.77587158977985, + 221.7520708218217, + 229.50255777686834, + 225.78510828316212, + 226.40311531722546, + 233.51528029888868, + 235.1070400327444, + 226.07320453971624, + 223.72455522418022, + 229.6711429953575, + 233.8759684935212, + 232.5167879462242, + 225.7696259766817, + 226.00264102220535, + 230.32126855105162, + 235.3748520836234, + 227.12932154536247, + 281.37343283742666, + 231.8929461762309, + 221.10623214393854, + 230.0674831494689, + 230.4131332784891, + 228.13278809189796, + 223.08641113340855, + 227.8739269822836, + 244.5134436711669, + 225.78538488596678, + 233.53436030447483, + 237.21141275018454, + 243.48950758576393, + 293.26757974922657, + 231.93461634218693, + 228.5138936713338, + 234.12698414176702, + 234.27440971136093, + 235.74668914079666, + 236.15362402051687, + 232.14852716773748, + 231.06860555708408, + 227.69239731132984, + 218.83168071508408, + 218.5864830389619 + ], + "p50_ms": 230.36720091477036, + "p95_ms": 244.5134436711669, + "requests_per_second_serial": 4.302778981258027, + "peak_allocated_bytes": 9371713024, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 205.68576361984015, + 204.00900393724442, + 213.1697628647089, + 210.31024120748043, + 204.49514966458082, + 209.72805377095938, + 202.2080235183239, + 217.1978447586298, + 211.54249273240566, + 198.52754287421703, + 201.84866711497307, + 203.10145150870085, + 208.70645716786385, + 211.00507117807865, + 210.5264849960804, + 211.6888491436839, + 203.18759512156248, + 219.9083687737584, + 207.3988001793623, + 204.69382964074612, + 209.95858032256365, + 206.20763953775167, + 211.21167857199907, + 200.70700906217098, + 206.280960701406, + 207.32521452009678, + 204.67729959636927, + 207.329373806715, + 204.6101363375783, + 206.39473758637905, + 209.54891201108694, + 211.1618211492896, + 206.67358301579952, + 208.717773668468, + 206.36219903826714, + 212.39049546420574, + 206.53959829360247, + 210.25697700679302, + 211.02158352732658, + 216.08392521739006, + 201.10002346336842, + 200.36799274384975, + 211.7293430492282, + 215.4216170310974, + 205.77581319957972, + 204.95922211557627, + 212.1182419359684, + 208.88989232480526, + 203.9185594767332, + 196.8731740489602 + ], + "p50_ms": 207.3272941634059, + "p95_ms": 216.08392521739006, + "requests_per_second_serial": 4.815307516695799, + "peak_allocated_bytes": 9369593344, + "peak_reserved_bytes": 10567548928 + } + } + ] + }, + { + "id": "640x480-short-q1", + "size": [ + 640, + 480 + ], + "goal": "short", + "goal_repetitions": 1, + "questions": 1, + "status": "complete", + "fixture_sha256": "a531f1cbc8a5751009ab4e86b5f11cea417eb8179b117a14a63e289317b1c4f7", + "validation": { + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + } + }, + "usage": { + "input_tokens": 456, + "output_tokens": 0 + } + } + }, + "runs": [ + { + "run": 1, + "orders": [ + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ] + ], + "baseline": { + "latencies_ms": [ + 129.44999895989895, + 129.33422904461622, + 129.32723201811314, + 129.17195539921522, + 129.55212593078613, + 128.17894853651524, + 127.88530252873898, + 127.24996265023947, + 129.39235102385283, + 128.38715501129627, + 128.21478303521872, + 130.79560827463865, + 128.66217736154795, + 128.54216247797012, + 128.81212774664164, + 133.44349712133408, + 132.99365621060133, + 128.30938957631588, + 128.83330322802067, + 127.30369716882706, + 128.5732164978981, + 127.4952283129096, + 127.25552450865507, + 127.05704476684332, + 133.47091898322105, + 127.74472963064909, + 128.66341322660446, + 127.75066867470741, + 127.96718440949917, + 126.77304446697235, + 126.49902421981096, + 126.89859978854656, + 126.8398491665721, + 127.01314967125654, + 126.85991637408733, + 126.93946156650782, + 126.66755355894566, + 126.79006904363632, + 126.86415575444698, + 126.54046341776848, + 128.16726509481668, + 131.02193269878626, + 169.55048590898514, + 158.71358197182417, + 142.44801178574562, + 127.0490363240242, + 126.76629796624184, + 126.50941591709852, + 126.34080275893211, + 134.2065529897809 + ], + "p50_ms": 128.17310681566596, + "p95_ms": 142.44801178574562, + "requests_per_second_serial": 7.686068658794393, + "peak_allocated_bytes": 9494350848, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 130.46202715486288, + 131.80988002568483, + 129.3035540729761, + 129.6700844541192, + 128.24448943138123, + 128.46500892192125, + 127.18584202229977, + 133.58180783689022, + 128.59136704355478, + 133.55116918683052, + 128.35741695016623, + 130.39279263466597, + 128.645034506917, + 128.55948880314827, + 128.47344670444727, + 128.628714941442, + 128.293976187706, + 128.17369028925896, + 127.99406051635742, + 127.44611408561468, + 128.04521899670362, + 127.95623112469912, + 127.13075708597898, + 127.2005895152688, + 128.15275508910418, + 128.13285365700722, + 127.93259043246508, + 128.01117170602083, + 127.15244479477406, + 126.91498920321465, + 126.94728560745716, + 126.7988858744502, + 126.64385791867971, + 126.58238969743252, + 126.84433721005917, + 126.99045613408089, + 126.79908610880375, + 127.07431521266699, + 126.73074286431074, + 126.702263019979, + 127.03734170645475, + 133.50171875208616, + 159.027392975986, + 157.93010592460632, + 127.65105813741684, + 127.03090906143188, + 126.3917488977313, + 126.53183098882437, + 126.77128240466118, + 133.0375075340271 + ], + "p50_ms": 128.00261611118913, + "p95_ms": 133.58180783689022, + "requests_per_second_serial": 7.721430453072161, + "peak_allocated_bytes": 9494350848, + "peak_reserved_bytes": 10567548928 + } + }, + { + "run": 2, + "orders": [ + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ], + [ + "reuse", + "baseline" + ], + [ + "baseline", + "reuse" + ] + ], + "baseline": { + "latencies_ms": [ + 134.93515644222498, + 125.81048998981714, + 125.78294146806002, + 125.85827149450779, + 126.05751119554043, + 125.93141943216324, + 126.13771390169859, + 125.96502993255854, + 127.63479445129633, + 127.61692423373461, + 126.24598201364279, + 125.609265640378, + 125.96675381064415, + 126.17042846977711, + 125.9118253365159, + 126.05961039662361, + 126.21661461889744, + 133.3963479846716, + 126.3460936024785, + 126.56860146671534, + 126.4045275747776, + 126.84296630322933, + 126.2475997209549, + 126.70037522912025, + 126.28150451928377, + 126.35285686701536, + 126.48437451571226, + 126.35692860931158, + 127.82007362693548, + 126.872967928648, + 125.84720272570848, + 126.1876504868269, + 125.96957478672266, + 125.99955312907696, + 131.61208666861057, + 130.6408317759633, + 126.51513516902924, + 126.78324338048697, + 126.57172977924347, + 126.487260684371, + 126.8480084836483, + 126.80138740688562, + 126.25071406364441, + 126.47768948227167, + 126.65574625134468, + 126.44172832369804, + 126.46396644413471, + 126.70700158923864, + 127.90228985249996, + 127.33405642211437 + ], + "p50_ms": 126.42312794923782, + "p95_ms": 131.61208666861057, + "requests_per_second_serial": 7.8776347363044374, + "peak_allocated_bytes": 9494350848, + "peak_reserved_bytes": 10567548928 + }, + "reuse": { + "latencies_ms": [ + 134.48075484484434, + 126.25870201736689, + 126.04907806962729, + 126.20342709124088, + 126.82953383773565, + 125.79933181405067, + 125.90052466839552, + 125.45730546116829, + 125.72822533547878, + 126.54401548206806, + 125.87628699839115, + 125.93483552336693, + 125.95064006745815, + 126.00038480013609, + 125.98767783492804, + 125.95946248620749, + 125.98039675503969, + 127.4451157078147, + 126.80470291525126, + 127.17674113810062, + 126.5584509819746, + 126.8557021394372, + 126.55195780098438, + 126.48873310536146, + 126.13850738853216, + 132.02753942459822, + 126.15326792001724, + 127.06728931516409, + 126.38754025101662, + 126.2927744537592, + 126.38951186090708, + 125.90514868497849, + 125.59471186250448, + 126.19145214557648, + 125.95598958432674, + 127.20874696969986, + 126.5887375921011, + 126.60944554954767, + 126.69645063579082, + 126.7747450619936, + 126.6544433310628, + 126.3522021472454, + 126.6202013939619, + 130.29453437775373, + 126.76774244755507, + 126.4686705544591, + 126.4180839061737, + 126.55369006097317, + 128.17493174225092, + 126.42770353704691 + ], + "p50_ms": 126.42289372161031, + "p95_ms": 130.29453437775373, + "requests_per_second_serial": 7.889501473888174, + "peak_allocated_bytes": 9494350848, + "peak_reserved_bytes": 10567548928 + } + } + ] + } + ], + "environment": { + "python": "3.12.13", + "gpu": "NVIDIA GeForce RTX 4090", + "compute_capability": [ + 8, + 9 + ], + "cuda": "13.0", + "driver": "595.71.05", + "torch_num_threads": 64, + "torch_num_interop_threads": 64, + "packages": { + "torch": "2.14.0", + "torchvision": "0.29.0", + "transformers": "5.17.0", + "peft": "0.21.0", + "pillow": "11.3.0", + "safetensors": "0.8.0", + "triton": "3.8.0" + }, + "reference_revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f", + "base_revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", + "adapter_revision": "16818868b0cc7813808aae4e87b417657046ab79", + "dtype": "bfloat16", + "adapter_merged": false + }, + "load_ms": 18933.196923695505, + "adapter_modules": 178 +} diff --git a/recipe/cua_s1/experiments/rtx4090-reuse/paired.log b/recipe/cua_s1/experiments/rtx4090-reuse/paired.log new file mode 100644 index 0000000..ac16647 --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-reuse/paired.log @@ -0,0 +1,34 @@ +[transformers] `torch_dtype` is deprecated! Use `dtype` instead! + Loading weights: 0%| | 0/723 [00:00 Date: Mon, 28 Sep 2026 12:27:04 +0800 Subject: [PATCH 17/26] docs: record PR publication and verified experiment server shutdown --- docs/superpowers/plans/2026-09-28-cua-image-reuse.md | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/docs/superpowers/plans/2026-09-28-cua-image-reuse.md b/docs/superpowers/plans/2026-09-28-cua-image-reuse.md index 383b830..4d739f3 100644 --- a/docs/superpowers/plans/2026-09-28-cua-image-reuse.md +++ b/docs/superpowers/plans/2026-09-28-cua-image-reuse.md @@ -13,5 +13,9 @@ - [x] Harness: recipe/cua_s1/benchmark_image_reuse.py plus CPU tests. Check exact tensors, positions and probabilities before timed paired measurements; alternate order; record each sample and independent per-variant peak memory. Retain failed reports. Reuse profile_multimodal fixture and provenance helpers. - [x] GPU: use clean committed checkout, run CPU tests, correctness smoke then 16-case paired experiment (5 warmups, 2 x 50 iterations per variant), plus distinct questions. Separate count/trace verification from all timed calls. - [x] Review: independent spec review followed by quality review; resolve findings and re-run affected checks. -- [ ] Publication: document measured results and tensor contract, retain raw JSON, run lint/full tests, commit/push and create linked PR identifying #12/#15 dependencies. -- [ ] Shutdown: copy experiment artifacts locally, verify hashes, confirm no required GPU work remains, shut down server and verify provider/connection state. +- [x] Publication: document measured results and tensor contract, retain raw JSON, run lint/full tests, commit/push and create linked PR identifying #12/#15 dependencies. +- [x] Shutdown: copy experiment artifacts locally, verify hashes, confirm no required GPU work remains, shut down server and verify provider/connection state. + +## Completion evidence + +Published non-draft [PR #17](https://github.com/ThinkFlowLab/system1-omni/pull/17). The complete experiment archive was copied locally and its SHA-256 matched the GPU host. After publication, the platform shutdown command exited successfully; a subsequent SSH attempt was refused. No experiment process remained on the GPU before shutdown. From 224d88b07be354b3cfc99fe8e9096bed777eafeb Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 14:13:55 +0800 Subject: [PATCH 18/26] perf(cua-s1): project only final logits in reused path --- .../2026-09-28-cua-post-reuse-optimization.md | 20 ++ ...9-28-cua-post-reuse-optimization-design.md | 9 + recipe/cua_s1/benchmark_last_logits.py | 182 ++++++++++++++++++ src/models/cua_s1/multimodal/model.py | 19 +- tests/cua_s1/test_image_reuse.py | 1 + tests/cua_s1/test_last_logits_benchmark.py | 38 ++++ 6 files changed, 263 insertions(+), 6 deletions(-) create mode 100644 docs/superpowers/plans/2026-09-28-cua-post-reuse-optimization.md create mode 100644 docs/superpowers/specs/2026-09-28-cua-post-reuse-optimization-design.md create mode 100644 recipe/cua_s1/benchmark_last_logits.py create mode 100644 tests/cua_s1/test_last_logits_benchmark.py diff --git a/docs/superpowers/plans/2026-09-28-cua-post-reuse-optimization.md b/docs/superpowers/plans/2026-09-28-cua-post-reuse-optimization.md new file mode 100644 index 0000000..1425725 --- /dev/null +++ b/docs/superpowers/plans/2026-09-28-cua-post-reuse-optimization.md @@ -0,0 +1,20 @@ +# Cua-S1 Post-Reuse Optimization Implementation Plan + +> **For agentic workers:** Execute these steps in order in the isolated worktree; preserve independent profiling and timed results. + +**Goal:** Select and verify one optimization after image reuse, publish a reproducible PR, and shut down the GPU server. + +**Architecture:** Use the existing reference and reuse paths. Measure current kernel groups, then limit the output projection to one token only if the paired experiment shows a benefit. Store raw experiment evidence and a readable analysis under `recipe/cua_s1/experiments/`. + +**Tech Stack:** Python 3.12, PyTorch 2.14, Transformers 5.17, PEFT 0.21, RTX 4090. + +--- + +- [ ] Profile the unchanged reuse path with 1 and 8 questions; retain raw kernel groups, module invocation counts, traces, and source revision. +- [ ] Run a temporary paired exploration of full projection versus `logits_to_keep=1`, checking complete responses before timing. Select the candidate only if its effect is credible. +- [ ] Add a failing tensor integration test in `tests/cua_s1/test_image_reuse.py` proving the reused path passes `logits_to_keep=1`; run it on the GPU host or a torch-equipped environment. +- [ ] Modify only `score_reused` in `src/models/cua_s1/multimodal/model.py`; rerun the focused test and the full Cua-S1 suite. +- [ ] Add a paired benchmark recipe with explicit baseline selection, alternating order, raw samples, response parity, source and environment metadata, and peak allocated memory. +- [ ] Commit a clean source revision, transfer it to the GPU host, and run correctness and timed measurements. Review raw samples, variability, kernel changes, and single-question behavior. +- [ ] Publish result data and reproduction commands, run verification, push the branch, create and attach the PR. +- [ ] Archive and checksum complete GPU evidence locally, ensure no experiment is running, shut down the server, and verify it no longer accepts SSH. diff --git a/docs/superpowers/specs/2026-09-28-cua-post-reuse-optimization-design.md b/docs/superpowers/specs/2026-09-28-cua-post-reuse-optimization-design.md new file mode 100644 index 0000000..215b8df --- /dev/null +++ b/docs/superpowers/specs/2026-09-28-cua-post-reuse-optimization-design.md @@ -0,0 +1,9 @@ +# Cua-S1 optimization after request-local image reuse + +The user approved continuing the experiment after PR #17, publishing a complete PR, backing up evidence, and shutting down the GPU server. + +Profile the existing request-local reuse path on the same pinned RTX 4090 environment. Preserve an unmodified response and latency reference, and examine one- and eight-question cases with both repeated and distinct questions. CPU annotations, CUDA kernels, and synchronized end-to-end latency are different measurements and must not be added together. + +Three candidates follow from the existing implementation: compute only the final output-token projection, replace the PyTorch Gated DeltaNet/causal-convolution fallbacks, or capture a stable request shape with CUDA Graphs. The first is the smallest change and can be tested against the existing model contract. Select it only if a clean paired experiment shows a useful end-to-end gain and parity. Otherwise report the evidence and choose the next measured hotspot rather than claiming a speedup. + +If selected, pass `logits_to_keep=1` only in the reused multi-question path. The model still performs one language forward per question; the parameter limits the output head to the final hidden state, from which candidate probabilities are already read. Retain the old reference path for paired comparison. Confirm exact input embeddings and 3D positions, candidate probabilities within the pinned oracle tolerance, and identical decisions and complete responses. Benchmark 1/2/4/8 questions with alternating order, save individual samples and peak allocated memory, and record source/environment provenance. Document limitations and restore the GPU host to a stopped state after verified backup. diff --git a/recipe/cua_s1/benchmark_last_logits.py b/recipe/cua_s1/benchmark_last_logits.py new file mode 100644 index 0000000..bb1d5a9 --- /dev/null +++ b/recipe/cua_s1/benchmark_last_logits.py @@ -0,0 +1,182 @@ +"""Compare full and final-token output projection on the reused Cua-S1 path.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +from contextlib import contextmanager +from pathlib import Path +from types import SimpleNamespace + +from benchmark_image_reuse import distinct_fixture, paired_benchmark +from profile_multimodal import case_matrix, fixture, repository_state, write_json + + +@contextmanager +def projection_variants(engine): + """Execute the same reuse path with only the output-head keyword changed.""" + original = engine.model.forward + + def full_forward(*args, **kwargs): + kwargs.pop("logits_to_keep", None) + return original(*args, **kwargs) + + def last_forward(*args, **kwargs): + return original(*args, **kwargs) + + def execute(forward, request): + engine.model.forward = forward + return engine.predict(request) + + try: + yield SimpleNamespace( + predict_reference=lambda request: execute(full_forward, request), + predict=lambda request: execute(last_forward, request), + ) + finally: + engine.model.forward = original + + +def main(argv=None): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--weights", type=Path, required=True) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--case", action="append", default=[]) + parser.add_argument("--warmup", type=int, default=5) + parser.add_argument("--runs", type=int, default=2) + parser.add_argument("--iterations", type=int, default=30) + args = parser.parse_args(argv) + known = {case["id"] for case in case_matrix()} | {"640x480-distinct-q8"} + if len(args.case) != len(set(args.case)) or set(args.case) - known: + parser.error("--case contains duplicate or unknown case ids") + if min(args.warmup, args.runs, args.iterations) <= 0: + parser.error("warmup, runs, and iterations must be positive") + report_path = args.output / "report.json" + if report_path.exists(): + raise ValueError("output report already exists; use a fresh directory") + + from evaluate_multimodal import environment, measure + + from models.cua_s1.multimodal.model import MultimodalEngine + from models.cua_s1.multimodal.protocol import parse_request + + report = { + "schema_version": 1, + "status": "running", + "repository": repository_state(Path(__file__).resolve().parents[2]), + "environment": environment(), + "config": { + "warmup": args.warmup, + "runs": args.runs, + "iterations": args.iterations, + "case": args.case, + "concurrency": 1, + "timed_scope": "synchronized engine.predict with only logits_to_keep changed; excludes parsing, fixture creation, validation, and hooks", + }, + "cases": [], + } + args.output.mkdir(parents=True, exist_ok=True) + write_json(report_path, report) + try: + engine, report["load_ms"] = measure( + lambda: MultimodalEngine( + str(args.weights / "Qwen3.5-4B"), + str(args.weights / "cua-s1-4b-0.2/multimodal"), + ) + ) + report["adapter_modules"] = engine.adapter_modules + selected = case_matrix() + [{"id": "640x480-distinct-q8"}] + selected = [ + case for case in selected if not args.case or case["id"] in args.case + ] + for case in selected: + value = ( + distinct_fixture(args.output / "fixtures") + if case["id"] == "640x480-distinct-q8" + else fixture(case, args.output / "fixtures") + ) + request = parse_request(value) + item = { + "id": case["id"], + "questions": len(request.questions), + "fixture_sha256": hashlib.sha256( + json.dumps(value, sort_keys=True).encode() + ).hexdigest(), + "status": "running", + } + report["cases"].append(item) + write_json(report_path, report) + with projection_variants(engine) as variants: + shapes = [] + head = engine.model.get_base_model().lm_head + handle = head.register_forward_pre_hook( + lambda module, inputs, shapes=shapes: shapes.append( + list(inputs[0].shape) + ) + ) + try: + full = variants.predict_reference(request) + item["full_head_shapes"] = shapes[:] + shapes.clear() + last = variants.predict(request) + item["last_head_shapes"] = shapes[:] + finally: + handle.remove() + if full != last: + raise ValueError(f"{case['id']}: full response differs") + if len(item["full_head_shapes"]) != len(request.questions) or len( + item["last_head_shapes"] + ) != len(request.questions): + raise ValueError(f"{case['id']}: unexpected output-head calls") + if len(request.questions) > 1 and any( + shape[1] != 1 for shape in item["last_head_shapes"] + ): + raise ValueError(f"{case['id']}: output head was not limited") + item["exact_response_parity"] = True + runs = paired_benchmark( + variants, + request, + warmup=args.warmup, + runs=args.runs, + iterations=args.iterations, + ) + for run in runs: + run["full_projection"] = run.pop("baseline") + run["last_token_projection"] = run.pop("reuse") + run["orders"] = [ + [ + "full_projection" + if v == "baseline" + else "last_token_projection" + for v in order + ] + for order in run["orders"] + ] + item.update(status="complete", runs=runs) + write_json(report_path, report) + print( + f"{case['id']}: " + + json.dumps( + [ + [ + round(run[v]["p50_ms"], 2) + for v in ("full_projection", "last_token_projection") + ] + for run in runs + ] + ), + flush=True, + ) + report["status"] = "complete" + except Exception as exc: + report["status"] = "failed" + report["error"] = {"type": type(exc).__name__, "message": str(exc)} + raise + finally: + write_json(report_path, report) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/src/models/cua_s1/multimodal/model.py b/src/models/cua_s1/multimodal/model.py index 625c8c0..d99773c 100644 --- a/src/models/cua_s1/multimodal/model.py +++ b/src/models/cua_s1/multimodal/model.py @@ -71,11 +71,14 @@ def verify_weights(base: Path, adapter: Path): for root, names in allowed.items(): for path in root.rglob("*"): relative = path.relative_to(root) - if path.is_file() and relative.parts[0] != ".cache": - if relative.as_posix() not in names: - raise ValueError( - f"unlisted artifact may override pinned files: {relative}" - ) + if ( + path.is_file() + and relative.parts[0] != ".cache" + and relative.as_posix() not in names + ): + raise ValueError( + f"unlisted artifact may override pinned files: {relative}" + ) class _RequestImageProcessor: @@ -197,8 +200,12 @@ def score_reused(self, inputs, question: Question, features) -> list[float]: image_grid_thw=text_inputs.pop("image_grid_thw"), attention_mask=text_inputs.get("attention_mask"), ) + # Candidate scoring reads only the final position. output = self.model( - inputs_embeds=embeds, position_ids=position_ids, **text_inputs + inputs_embeds=embeds, + position_ids=position_ids, + logits_to_keep=1, + **text_inputs, ) logits = output.logits[0, -1, :] return torch.softmax( diff --git a/tests/cua_s1/test_image_reuse.py b/tests/cua_s1/test_image_reuse.py index 4d3eac5..4de22d7 100644 --- a/tests/cua_s1/test_image_reuse.py +++ b/tests/cua_s1/test_image_reuse.py @@ -232,6 +232,7 @@ def __call__(self, **kwargs): assert not torch.is_grad_enabled() assert "input_ids" not in kwargs and "pixel_values" not in kwargs assert "image_grid_thw" not in kwargs + assert kwargs["logits_to_keep"] == 1 assert torch.equal(kwargs["position_ids"], positions) assert torch.equal( kwargs["inputs_embeds"], diff --git a/tests/cua_s1/test_last_logits_benchmark.py b/tests/cua_s1/test_last_logits_benchmark.py new file mode 100644 index 0000000..a417d13 --- /dev/null +++ b/tests/cua_s1/test_last_logits_benchmark.py @@ -0,0 +1,38 @@ +"""The paired experiment must compare only output projection scope.""" + +import importlib.util +from pathlib import Path +from types import SimpleNamespace + + +def test_projection_variants_change_only_forward_keyword(monkeypatch): + recipe = Path(__file__).resolve().parents[2] / "recipe/cua_s1" + monkeypatch.syspath_prepend(str(recipe)) + spec = importlib.util.spec_from_file_location( + "benchmark_last_logits", recipe / "benchmark_last_logits.py" + ) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + + calls = [] + + def forward(**kwargs): + calls.append(kwargs) + return kwargs + + model = SimpleNamespace(forward=forward) + engine = SimpleNamespace(model=model) + engine.predict = lambda request: engine.model.forward( + inputs_embeds="same", logits_to_keep=1 + ) + with module.projection_variants(engine) as variants: + assert variants.predict_reference(None) == {"inputs_embeds": "same"} + assert variants.predict(None) == { + "inputs_embeds": "same", + "logits_to_keep": 1, + } + assert model.forward is forward + assert calls == [ + {"inputs_embeds": "same"}, + {"inputs_embeds": "same", "logits_to_keep": 1}, + ] From 89e35e9909f5f9959208c0231ea90a1619c58840 Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 14:41:23 +0800 Subject: [PATCH 19/26] docs(cua-s1): publish RTX 4090 final-logits experiment --- .../2026-09-28-cua-post-reuse-optimization.md | 12 +- .../experiments/rtx4090-last-logits/README.md | 125 + .../rtx4090-last-logits/SHA256SUMS | 7 + .../rtx4090-last-logits/correctness.json | 4458 ++++ .../rtx4090-last-logits/correctness.log | 17 + .../rtx4090-last-logits/paired.json | 7851 +++++++ .../rtx4090-last-logits/paired.log | 21 + .../rtx4090-last-logits/postflight.json | 656 + .../rtx4090-last-logits/postflight.log | 5 + .../rtx4090-last-logits/reuse-profile.json | 17741 ++++++++++++++++ .../rtx4090-last-logits/verify_results.py | 118 + 11 files changed, 31005 insertions(+), 6 deletions(-) create mode 100644 recipe/cua_s1/experiments/rtx4090-last-logits/README.md create mode 100644 recipe/cua_s1/experiments/rtx4090-last-logits/SHA256SUMS create mode 100644 recipe/cua_s1/experiments/rtx4090-last-logits/correctness.json create mode 100644 recipe/cua_s1/experiments/rtx4090-last-logits/correctness.log create mode 100644 recipe/cua_s1/experiments/rtx4090-last-logits/paired.json create mode 100644 recipe/cua_s1/experiments/rtx4090-last-logits/paired.log create mode 100644 recipe/cua_s1/experiments/rtx4090-last-logits/postflight.json create mode 100644 recipe/cua_s1/experiments/rtx4090-last-logits/postflight.log create mode 100644 recipe/cua_s1/experiments/rtx4090-last-logits/reuse-profile.json create mode 100644 recipe/cua_s1/experiments/rtx4090-last-logits/verify_results.py diff --git a/docs/superpowers/plans/2026-09-28-cua-post-reuse-optimization.md b/docs/superpowers/plans/2026-09-28-cua-post-reuse-optimization.md index 1425725..261e072 100644 --- a/docs/superpowers/plans/2026-09-28-cua-post-reuse-optimization.md +++ b/docs/superpowers/plans/2026-09-28-cua-post-reuse-optimization.md @@ -10,11 +10,11 @@ --- -- [ ] Profile the unchanged reuse path with 1 and 8 questions; retain raw kernel groups, module invocation counts, traces, and source revision. -- [ ] Run a temporary paired exploration of full projection versus `logits_to_keep=1`, checking complete responses before timing. Select the candidate only if its effect is credible. -- [ ] Add a failing tensor integration test in `tests/cua_s1/test_image_reuse.py` proving the reused path passes `logits_to_keep=1`; run it on the GPU host or a torch-equipped environment. -- [ ] Modify only `score_reused` in `src/models/cua_s1/multimodal/model.py`; rerun the focused test and the full Cua-S1 suite. -- [ ] Add a paired benchmark recipe with explicit baseline selection, alternating order, raw samples, response parity, source and environment metadata, and peak allocated memory. -- [ ] Commit a clean source revision, transfer it to the GPU host, and run correctness and timed measurements. Review raw samples, variability, kernel changes, and single-question behavior. +- [x] Profile the unchanged reuse path with 1 and 8 questions; retain raw kernel groups, module invocation counts, traces, and source revision. +- [x] Run a temporary paired exploration of full projection versus `logits_to_keep=1`, checking complete responses before timing. Select the candidate only if its effect is credible. +- [x] Add a failing tensor integration test in `tests/cua_s1/test_image_reuse.py` proving the reused path passes `logits_to_keep=1`; run it on the GPU host or a torch-equipped environment. +- [x] Modify `score_reused` in `src/models/cua_s1/multimodal/model.py` and clean up a nearby Ruff guard; rerun the focused test and the full Cua-S1 suite. +- [x] Add a paired benchmark recipe with explicit baseline selection, alternating order, raw samples, response parity, source and environment metadata, and peak allocated memory. +- [x] Commit a clean source revision, transfer it to the GPU host, and run correctness and timed measurements. Review raw samples, variability, kernel changes, and single-question behavior. - [ ] Publish result data and reproduction commands, run verification, push the branch, create and attach the PR. - [ ] Archive and checksum complete GPU evidence locally, ensure no experiment is running, shut down the server, and verify it no longer accepts SSH. diff --git a/recipe/cua_s1/experiments/rtx4090-last-logits/README.md b/recipe/cua_s1/experiments/rtx4090-last-logits/README.md new file mode 100644 index 0000000..5fcaa12 --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-last-logits/README.md @@ -0,0 +1,125 @@ +# RTX 4090 final-token projection after image reuse — 2026-09-28 + +The request-local reuse path previously projected every language hidden state to +the 248,320-word vocabulary, then read only the last position to score choices. +Passing `logits_to_keep=1` to the pinned Transformers model projects that final +position alone. This change is limited to multi-question requests; the +single-question path remains the existing reference path. + +Across 13 multi-question cases and two runs each, synchronized `engine.predict` +p50 fell **0.5–5.3%** (median reduction **3.4%**). The 640×480 screenshot with +eight different questions fell from **852.40 / 881.26 ms** to **822.68 / 851.65 +ms**. Four single-question controls changed by **−0.4% to +0.2%** and are treated +as measurement noise. All 17 cases returned exactly the same full response with +the full and limited projections; no numerical tolerance was needed. + +## Provenance and measurement + +- Clean measured source: `224d88b07be354b3cfc99fe8e9096bed777eafeb`. + [paired.json](paired.json) records its revision, clean status, environment, + every sample, alternating call order, p50/p95 and allocated/reserved peaks. +- NVIDIA RTX 4090 24,564 MiB, driver 595.71.05, CUDA runtime 13.0, Python + 3.12.13, PyTorch 2.14.0, Transformers 5.17.0, PEFT 0.21.0, BF16 base with + unmerged multimodal LoRA. The 178 adapted modules and fallback Gated DeltaNet + and causal-convolution paths match PR #17. No package or model revision changed. +- Original 16-case matrix (two screenshot sizes, short/long instructions, + 1/2/4/8 repeated questions) plus eight distinct questions on a 640×480 image. + Five warmup calls per variant and case, then two runs of 30 calls per variant: + **2,040 timed predictions**. The order alternates each pair and reverses in + the second run. CUDA is synchronized around each prediction. Hooks and the + profiler are absent from timed samples. +- Both timed variants use the **same request-local image reuse path**. A temporary + benchmark wrapper removes `logits_to_keep` for the full-projection comparison; + the candidate retains it. Thus this experiment isolates output projection, + unlike PR #17's before/after image-reuse comparison. +- Timing includes processor work and engine inference after request parsing. + It excludes image decoding, HTTP, queueing, model load, correctness checks and + profiling. Measurements are serial, concurrency 1. + +| Case | Full p50 ms, runs 1 / 2 | Final-token p50 ms, runs 1 / 2 | p50 reduction | Peak allocated GiB, full → final | +| --- | ---: | ---: | ---: | ---: | +| 320×240 short, 1 question | 107.78 / 107.98 | 107.88 / 107.72 | −0.1% / +0.2% | 8.728 → 8.728 | +| 320×240 short, 8 questions | 716.83 / 715.95 | 711.50 / 705.99 | 0.7% / 1.4% | 8.726 → 8.677 | +| 320×240 long, 8 questions | 957.85 / 929.54 | 924.68 / 892.63 | 3.5% / 4.0% | 8.920 → 8.776 | +| 640×480 short, 1 question | 126.08 / 125.59 | 125.95 / 125.65 | +0.1% / −0.0% | 8.843 → 8.843 | +| 640×480 short, 8 questions | 857.32 / 901.78 | 830.27 / 875.32 | 3.2% / 2.9% | 8.838 → 8.739 | +| 640×480 long, 8 questions | 1086.47 / 1126.04 | 1029.76 / 1066.46 | 5.2% / 5.3% | 9.034 → 8.840 | +| 640×480 distinct, 8 questions | 852.40 / 881.26 | 822.68 / 851.65 | 3.5% / 3.4% | 8.994 → 8.812 | + +The independent [verification script](verify_results.py) recomputes all 17 rows, +including p95, from every saved sample; the displayed rows are representative. +For 640×480 long, eight questions, peak allocated memory fell by **0.194 GiB**. +Reserved memory may persist across variants, so allocated memory is the useful +peak comparison here. + +## Correctness and hotspot evidence + +- [correctness.json](correctness.json): 13 fixtures / 49 question forwards per + path. Prepared tensors, language embeddings, masks, three-dimensional positions, + candidate probabilities and full responses are exactly equal to the original + execution path. Vision executes once and language executes once per question. + The fixtures include different goals, candidate counts and ordering, Unicode, + PNG/JPEG and consecutive image changes. Unit tests cover failure recovery. +- [paired.json](paired.json): exact full-response parity for each of the 17 timed + cases. Its output-head pre-hooks record an input change from `[1, 456, 2560]` + to `[1, 1, 2560]` for every question in the 640×480 short, eight-question case; + for eight distinct questions, `[1, 443, 2560]` becomes `[1, 1, 2560]` for + the first question. Single-question head shapes are unchanged. +- [reuse-profile.json](reuse-profile.json): an **untimed** trace on the prior + reused path at clean source `9f4a4fe` shows one visual forward, eight language + forwards and eight output projections. Its shape-grouped `aten::mm` with + inputs `[456, 2560]` and + `[2560, 248320]` occurs eight times and records 35.93 ms of device time. This + identifies the targeted output projection; profiled kernel time is not an + additive estimate of end-to-end savings. Full Chrome traces are retained in + the separate evidence archive because they are hundreds of MiB. +- [postflight.json](postflight.json): actual CUDA layout, HTTP health 200 and + eight-question worker response 200, exactly equal to direct engine output. + The clean GPU-host Cua-S1 suite passed **105 tests**; local macOS passed + **104**, with one torch-dependent tensor test skipped locally. Ruff lint and + formatting checks passed. + +## Reproduce + +Run from a clean checkout with the pinned environment and verified weights: + +```sh +PYTHONPATH=src:recipe/cua_s1 python recipe/cua_s1/benchmark_last_logits.py \ + --weights /path/to/weights --output /path/to/fresh-output \ + --warmup 5 --runs 2 --iterations 30 +python recipe/cua_s1/experiments/rtx4090-last-logits/verify_results.py +``` + +For the full reference-versus-reuse correctness sweep and real HTTP check: + +```sh +PYTHONPATH=src:recipe/cua_s1 python recipe/cua_s1/benchmark_image_reuse.py \ + --weights /path/to/weights --output /path/to/fresh-correctness \ + --correctness-only +PYTHONPATH=src:recipe/cua_s1 python \ + recipe/cua_s1/experiments/rtx4090-reuse/postflight.py \ + /path/to/clean-repository /path/to/weights /path/to/fresh-postflight +``` + +The checked-in audit reads this directory's `paired.json`. To audit a fresh +run, copy its `report.json` to `paired.json` in a copy of this directory. The +profiling groups and Chrome traces are retained as separate evidence from the +timed benchmark. [SHA256SUMS](SHA256SUMS) identifies the checked-in data files +and logs. + +The complete experiment directory, including all three large Chrome traces, +generated fixtures, logs and the measured source bundle, was copied to the +local ignored `work/20260928-post-reuse-evidence.tar.gz` before server shutdown. +The server and local archive SHA-256 matched: +`774d952e89a9586709419c6c8583e4aa7ee2d27b4bf836253c8c01881c4dccd9` +(25,231,406 compressed bytes). The checked-in JSON is sufficient to audit the +latency claims without this archive. + +## Limits and next step + +These numbers describe synthetic screenshots and serial, prefill-only engine +calls on one pinned RTX 4090 configuration. They do not establish HTTP +throughput, p99, GUI-task quality, native-engine support, CUDA Graph benefits or +Metal performance. The output projection is now bounded by the last token; +the remaining repeated language forwards and PyTorch fallback kernels are the +next candidates for measurement and validation. diff --git a/recipe/cua_s1/experiments/rtx4090-last-logits/SHA256SUMS b/recipe/cua_s1/experiments/rtx4090-last-logits/SHA256SUMS new file mode 100644 index 0000000..18e4a3f --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-last-logits/SHA256SUMS @@ -0,0 +1,7 @@ +2128f2904081f8d2353a87e4fb5b2197411a85298b228b404e6682ed4ee2d8c2 paired.json +624c05398d013a84e4f17bd7fd35c99575354fabd59aec8d98a59e0a1ee13a4f correctness.json +b72315ff79097d05dba9f93094a68bea25cda9d9d013041b5eac6464688406fd postflight.json +591662d886215a4d629373c7da55b88287189ef8b56468816eed328c6b56c3e8 reuse-profile.json +6a40b0d4b17c925aa1a98422fe8d89c1cdfbc1e2409d8a33f73780737f243555 paired.log +e3f9b7223191a04f9e2b34201bda02aa559ceaf246af24852787ba514ec49a9b correctness.log +d46cbbec5568f3fc7090edc7d146de0afc1b19cbb4c36877708453e2981243db postflight.log diff --git a/recipe/cua_s1/experiments/rtx4090-last-logits/correctness.json b/recipe/cua_s1/experiments/rtx4090-last-logits/correctness.json new file mode 100644 index 0000000..486ae84 --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-last-logits/correctness.json @@ -0,0 +1,4458 @@ +{ + "schema_version": 1, + "status": "complete", + "repository": { + "revision": "224d88b07be354b3cfc99fe8e9096bed777eafeb", + "dirty": false, + "diff_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "untracked_files": [] + }, + "config": { + "warmup": 5, + "runs": 2, + "iterations": 50, + "correctness_only": true, + "selected_cases": [], + "case_order_seed": 20260928, + "concurrency": 1, + "batch_size": 1, + "timed_scope": "synchronized engine.predict; excludes HTTP, parsing, image decode, validation instrumentation" + }, + "correctness": [ + { + "id": "small", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + } + }, + "usage": { + "input_tokens": 236, + "output_tokens": 0 + } + } + }, + { + "id": "medium", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "3bff8b362bae7c1847742e791feb17bb871c053464424b161e7c6fdc11ce4233" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + } + }, + "usage": { + "input_tokens": 456, + "output_tokens": 0 + } + } + }, + { + "id": "jpeg", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 456, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "8563e2d6f4bc4a9c1a594d53c0c5c4062760ffca599922127b53e64df8986603" + }, + "position_ids": { + "shape": [ + 3, + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "5ae870bec42a18b88346718c328e0e4a609fe6f5ac1f3ee2546d6f5aebf4531c" + }, + "attention_mask": { + "shape": [ + 1, + 456 + ], + "dtype": "torch.int64", + "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9936226010322571, + "cancel": 0.0011634123511612415, + "wait": 0.005214052740484476 + }, + "confidence": 0.9621116268179815 + } + }, + "usage": { + "input_tokens": 456, + "output_tokens": 0 + } + } + }, + { + "id": "single", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "c4d7b1102e94984504efa938052a0bba3639ba85f9917de3e8af5426ceefd16b" + }, + "attention_mask": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "3419eb840bd7f9d9e4b1fa6aaea783bae7a4752068701794687337702c2d8968" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "077d91126e88fd3e8ba97a2d8079c28a4d5da388e56c89ca0e584fd5ad4b3641" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 431, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "637e12e3d1ac73afc9258c509ed8724b6171bae8a0ce5a39e870cf8c250442e6" + }, + "position_ids": { + "shape": [ + 3, + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "36312a68dabf34c5fdadce5e51ec9a97606fc7aa87087d166ca310623235d10d" + }, + "attention_mask": { + "shape": [ + 1, + 431 + ], + "dtype": "torch.int64", + "sha256": "3419eb840bd7f9d9e4b1fa6aaea783bae7a4752068701794687337702c2d8968" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "only", + "probabilities": { + "only": 1.0 + }, + "confidence": 1.0 + } + }, + "usage": { + "input_tokens": 431, + "output_tokens": 0 + } + } + }, + { + "id": "26-options", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 752, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cd572e59171ef52d8e37644cbbdbbf9ff86d77d31cf48b19c4821d7349c026f7" + }, + "position_ids": { + "shape": [ + 3, + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "3d615db0cf3b07f33f32c5d24335f9abdd5b4599e5de79b20326f339520128d1" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "option-3", + "probabilities": { + "option-0": 0.07546718418598175, + "option-1": 0.00034948240499943495, + "option-2": 0.263406366109848, + "option-3": 0.557631254196167, + "option-4": 0.009013270027935505, + "option-5": 0.01908109337091446, + "option-6": 0.007019542157649994, + "option-7": 0.016839005053043365, + "option-8": 0.009013270027935505, + "option-9": 0.0025823453906923532, + "option-10": 0.004824455827474594, + "option-11": 0.003315796609967947, + "option-12": 0.002011132426559925, + "option-13": 0.0022789116483181715, + "option-14": 0.00619472423568368, + "option-15": 0.0010764816543087363, + "option-16": 0.0037572900764644146, + "option-17": 0.0006529190577566624, + "option-18": 0.002011132426559925, + "option-19": 0.0012198134791105986, + "option-20": 0.00044874430750496686, + "option-21": 0.0005084939184598625, + "option-22": 0.003315796609967947, + "option-23": 0.0013822298496961594, + "option-24": 0.0017748181708157063, + "option-25": 0.004824455827474594 + }, + "confidence": 0.5755459268738158 + } + }, + "usage": { + "input_tokens": 752, + "output_tokens": 0 + } + } + }, + { + "id": "structured", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 469, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "fecbffc833f744dd32c6b0296b399ef7256ded521c75fd8a5dfb2fd6f5e3c762" + }, + "position_ids": { + "shape": [ + 3, + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "a679452a2039eff05da911d8657b1857f058184d4bb373cd35576f7d3bfca410" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "object", + "probabilities": { + "null": 0.07443060725927353, + "object": 0.9067503809928894, + "array": 0.01881900243461132 + }, + "confidence": 0.6751463333759231 + } + }, + "usage": { + "input_tokens": 469, + "output_tokens": 0 + } + } + }, + { + "id": "special-token", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "reuse_counts": { + "vision": 1, + "language": 1, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "a075316b24c03cafe09f612e8c4499e0c87035b098bf3db6f8023f7be18c405d" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "first", + "probabilities": { + "first": 0.531209409236908, + "second": 0.4687906503677368 + }, + "confidence": 0.002812297157495758 + } + }, + "usage": { + "input_tokens": 441, + "output_tokens": 0 + } + } + }, + { + "id": "two-questions", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 2, + "language": 2, + "image_preprocess": 2 + }, + "reuse_counts": { + "vision": 1, + "language": 2, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "1bc665c3f5aa0134e368d1a9edf0e652ec604cf43e969d59b14f696a4cf5c9c3" + }, + "attention_mask": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "bbdd8ad88f622ea9585a6b471f3ef6810a0c3374e43dbcb747e3077de4e6e674" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "6dc930bb14d93a028e6d2db398b391c4fe5af99184ec6625d38d2f7820e182f3" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 236, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "00aaef687cf64bba1537126a6397ccfc7b62971edae816049a7f410b858b13cf" + }, + "position_ids": { + "shape": [ + 3, + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "a55864ed6cfc6bbde65dcaec6b7c8cc2462a0f603045eccdee9ef868bd61dcc0" + }, + "attention_mask": { + "shape": [ + 1, + 236 + ], + "dtype": "torch.int64", + "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 215, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "d12d91036735b6503b458045529a1f5368721c551fbcb0681196c8a70006fbb8" + }, + "position_ids": { + "shape": [ + 3, + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "58dafa9b49c13c2f1ae8214fb18e76b5d932313605785742a8a93415f8d954b3" + }, + "attention_mask": { + "shape": [ + 1, + 215 + ], + "dtype": "torch.int64", + "sha256": "bbdd8ad88f622ea9585a6b471f3ef6810a0c3374e43dbcb747e3077de4e6e674" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "next": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9958575367927551, + "cancel": 0.0005507932510226965, + "wait": 0.003591623157262802 + }, + "confidence": 0.9740719299887141 + }, + "second": { + "type": "choice", + "choice": "no", + "probabilities": { + "yes": 0.22270014882087708, + "no": 0.7772998809814453 + }, + "confidence": 0.23493269546473194 + } + }, + "usage": { + "input_tokens": 451, + "output_tokens": 0 + } + } + }, + { + "id": "distinct-eight", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 8, + "language": 8, + "image_preprocess": 8 + }, + "reuse_counts": { + "vision": 1, + "language": 8, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "0d717f46abbc57e2696c66d4969fc777e96415a6f67740a7087cf77d78de218d" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "ff71ef4e6c311c56cd3dbe484f8a05773dba0361b21e97745ca7394758319d1c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "eb7ea7dd8487457bc025d44ba5ebc1550026250abea05f847d61b8ea6f52af8e" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "60b6d77d34ada12b8def875237be8cd0feee4475ccf4cb389bd44245b21a8f9d" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "c0e9e08d7a1863b1e91cca10457d593e1281ccd5695cfb89683b8121826cff38" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8de01e028cd92e75ba21cf901916223dc844a7c580f8bb2b943828403cb28198" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "cc047cd8ed2d1ddd4493abd7cff8ee7ba9fcd0b6265e1a1b8b4b2f6c6e822390" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "6fd0e47d02ff77335d5b2733962a9f7a1caed5ea867aa67b8c3b4b788509dba1" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "deb3cc137c72ac7e023b78a4d29d507ddf95f02f2572e38dd068a3574116ac21" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 443, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "c108e3059ad63ab2efd4d2d194766ab18ef6144819985ff6448dae85f476b032" + }, + "position_ids": { + "shape": [ + 3, + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "9e4fd6391bea467b1a278b2506d278b0ae583fc15a686a31882dc377374e04d1" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 442, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "db88bedddbbd1d2b6aaf63664379d5206b0de9ef3fcf0ccdd0fb951599364847" + }, + "position_ids": { + "shape": [ + 3, + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "f706ff63624d02735d39ebe7097dc53d833763276475713d80259d5fed6d7446" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 426, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "b464ff04b79496dcab96f3a8b588a4bc5e611075d4e44ff7b526eaa685658b4a" + }, + "position_ids": { + "shape": [ + 3, + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "edacad438038fb1d85e9097dd2de086c8f14696351353792f13df88e99e9de7b" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 752, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cd572e59171ef52d8e37644cbbdbbf9ff86d77d31cf48b19c4821d7349c026f7" + }, + "position_ids": { + "shape": [ + 3, + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "3d615db0cf3b07f33f32c5d24335f9abdd5b4599e5de79b20326f339520128d1" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 469, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "fecbffc833f744dd32c6b0296b399ef7256ded521c75fd8a5dfb2fd6f5e3c762" + }, + "position_ids": { + "shape": [ + 3, + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "a679452a2039eff05da911d8657b1857f058184d4bb373cd35576f7d3bfca410" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "a075316b24c03cafe09f612e8c4499e0c87035b098bf3db6f8023f7be18c405d" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 460, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0472dbfc0ad390d48f2d4340f8688dfb77298cede625d8d070c3ec3648cd712b" + }, + "position_ids": { + "shape": [ + 3, + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "506ff79aaba73a3bd70f9b1fac38badd9497de8377e2db255b1322b7ae308b86" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cb1f6fae46aaeb1f6b21beafd94e066b87b0bd4a02e7f10bf6f0e991cbc43f49" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.998498797416687, + "cancel": 0.0015011822106316686 + }, + "confidence": 0.9837552323853659 + }, + "q2": { + "type": "choice", + "choice": "cancel", + "probabilities": { + "cancel": 0.9995121955871582, + "save": 0.00048785717808641493 + }, + "confidence": 0.9939293781678539 + }, + "q3": { + "type": "choice", + "choice": "only", + "probabilities": { + "only": 1.0 + }, + "confidence": 1.0 + }, + "q4": { + "type": "choice", + "choice": "option-3", + "probabilities": { + "option-0": 0.07546718418598175, + "option-1": 0.00034948240499943495, + "option-2": 0.263406366109848, + "option-3": 0.557631254196167, + "option-4": 0.009013270027935505, + "option-5": 0.01908109337091446, + "option-6": 0.007019542157649994, + "option-7": 0.016839005053043365, + "option-8": 0.009013270027935505, + "option-9": 0.0025823453906923532, + "option-10": 0.004824455827474594, + "option-11": 0.003315796609967947, + "option-12": 0.002011132426559925, + "option-13": 0.0022789116483181715, + "option-14": 0.00619472423568368, + "option-15": 0.0010764816543087363, + "option-16": 0.0037572900764644146, + "option-17": 0.0006529190577566624, + "option-18": 0.002011132426559925, + "option-19": 0.0012198134791105986, + "option-20": 0.00044874430750496686, + "option-21": 0.0005084939184598625, + "option-22": 0.003315796609967947, + "option-23": 0.0013822298496961594, + "option-24": 0.0017748181708157063, + "option-25": 0.004824455827474594 + }, + "confidence": 0.5755459268738158 + }, + "q5": { + "type": "choice", + "choice": "object", + "probabilities": { + "null": 0.07443060725927353, + "object": 0.9067503809928894, + "array": 0.01881900243461132 + }, + "confidence": 0.6751463333759231 + }, + "q6": { + "type": "choice", + "choice": "first", + "probabilities": { + "first": 0.531209409236908, + "second": 0.4687906503677368 + }, + "confidence": 0.002812297157495758 + }, + "q7": { + "type": "choice", + "choice": "yes", + "probabilities": { + "yes": 0.9823379516601562, + "no": 0.0035428637638688087, + "wait": 0.006618940737098455, + "help": 0.007500242441892624 + }, + "confidence": 0.9225223144825633 + }, + "q8": { + "type": "choice", + "choice": "leave", + "probabilities": { + "stay": 0.01798621006309986, + "leave": 0.9820137619972229 + }, + "confidence": 0.8700206851739604 + } + }, + "usage": { + "input_tokens": 3874, + "output_tokens": 0 + } + } + }, + { + "id": "distinct-jpeg", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 8, + "language": 8, + "image_preprocess": 8 + }, + "reuse_counts": { + "vision": 1, + "language": 8, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "0d717f46abbc57e2696c66d4969fc777e96415a6f67740a7087cf77d78de218d" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "ff71ef4e6c311c56cd3dbe484f8a05773dba0361b21e97745ca7394758319d1c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "eb7ea7dd8487457bc025d44ba5ebc1550026250abea05f847d61b8ea6f52af8e" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "60b6d77d34ada12b8def875237be8cd0feee4475ccf4cb389bd44245b21a8f9d" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "c0e9e08d7a1863b1e91cca10457d593e1281ccd5695cfb89683b8121826cff38" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8de01e028cd92e75ba21cf901916223dc844a7c580f8bb2b943828403cb28198" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "cc047cd8ed2d1ddd4493abd7cff8ee7ba9fcd0b6265e1a1b8b4b2f6c6e822390" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "6fd0e47d02ff77335d5b2733962a9f7a1caed5ea867aa67b8c3b4b788509dba1" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "deb3cc137c72ac7e023b78a4d29d507ddf95f02f2572e38dd068a3574116ac21" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 443, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "a589f8282553e6db720ee42d435325c1b11c97a64cb863905aa14caf666ae9c2" + }, + "position_ids": { + "shape": [ + 3, + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "9e4fd6391bea467b1a278b2506d278b0ae583fc15a686a31882dc377374e04d1" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 442, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "bb28cc0469fe66ba66db8fc5dcc38441e6b19fe179eefe44ca266218ab23158c" + }, + "position_ids": { + "shape": [ + 3, + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "f706ff63624d02735d39ebe7097dc53d833763276475713d80259d5fed6d7446" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 426, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "e2162bdf94dc7edb76358f4a41d47550fdf417315858da8def30e97d09e49dd3" + }, + "position_ids": { + "shape": [ + 3, + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "edacad438038fb1d85e9097dd2de086c8f14696351353792f13df88e99e9de7b" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 752, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "e9b818b64d6deba45993bde264f03a346381ffa6115fd3ff77dd6e5a4f42f66a" + }, + "position_ids": { + "shape": [ + 3, + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "3d615db0cf3b07f33f32c5d24335f9abdd5b4599e5de79b20326f339520128d1" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 469, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "32b8963f7691bc77156406010aefdd906eaf36b32870ae7854b89a2d0744f47d" + }, + "position_ids": { + "shape": [ + 3, + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "a679452a2039eff05da911d8657b1857f058184d4bb373cd35576f7d3bfca410" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "5b8c4b14a06f1caa45fd89cf48f782a118c66a7b12908cdf41ec6963b8335c10" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 460, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "fceb2a3f05e5b84236e9df40a07c54ba71c56544737d4348ce045f6492026039" + }, + "position_ids": { + "shape": [ + 3, + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "506ff79aaba73a3bd70f9b1fac38badd9497de8377e2db255b1322b7ae308b86" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "151e9a9b4df949b7475a5617f97b1201d5bd472639088322ee1d981bf5de3103" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.998498797416687, + "cancel": 0.0015011822106316686 + }, + "confidence": 0.9837552323853659 + }, + "q2": { + "type": "choice", + "choice": "cancel", + "probabilities": { + "cancel": 0.9991958737373352, + "save": 0.0008040859247557819 + }, + "confidence": 0.9905740626396378 + }, + "q3": { + "type": "choice", + "choice": "only", + "probabilities": { + "only": 1.0 + }, + "confidence": 1.0 + }, + "q4": { + "type": "choice", + "choice": "option-3", + "probabilities": { + "option-0": 0.07067349553108215, + "option-1": 0.0002888264134526253, + "option-2": 0.31673663854599, + "option-3": 0.522210419178009, + "option-4": 0.007448931224644184, + "option-5": 0.013916435651481152, + "option-6": 0.006573658902198076, + "option-7": 0.013916435651481152, + "option-8": 0.007448931224644184, + "option-9": 0.002134154550731182, + "option-10": 0.004518005531281233, + "option-11": 0.0031051766127347946, + "option-12": 0.001883384888060391, + "option-13": 0.001883384888060391, + "option-14": 0.006573658902198076, + "option-15": 0.001142330700531602, + "option-16": 0.003987125586718321, + "option-17": 0.0006928585353307426, + "option-18": 0.001883384888060391, + "option-19": 0.001142330700531602, + "option-20": 0.00042023995774798095, + "option-21": 0.00042023995774798095, + "option-22": 0.003987125586718321, + "option-23": 0.001142330700531602, + "option-24": 0.001883384888060391, + "option-25": 0.003987125586718321 + }, + "confidence": 0.5842158243885958 + }, + "q5": { + "type": "choice", + "choice": "null", + "probabilities": { + "null": 0.46689873933792114, + "object": 0.2831884026527405, + "array": 0.24991288781166077 + }, + "confidence": 0.0356628420875128 + }, + "q6": { + "type": "choice", + "choice": "second", + "probabilities": { + "first": 0.3486451506614685, + "second": 0.6513549089431763 + }, + "confidence": 0.06714781287071625 + }, + "q7": { + "type": "choice", + "choice": "yes", + "probabilities": { + "yes": 0.9716947674751282, + "no": 0.009526160545647144, + "wait": 0.006547227967530489, + "help": 0.01223183237016201 + }, + "confidence": 0.8852895522159283 + }, + "q8": { + "type": "choice", + "choice": "leave", + "probabilities": { + "stay": 0.020332353189587593, + "leave": 0.9796676635742188 + }, + "confidence": 0.8566974578024523 + } + }, + "usage": { + "input_tokens": 3874, + "output_tokens": 0 + } + } + }, + { + "id": "distinct-reversed", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 8, + "language": 8, + "image_preprocess": 8 + }, + "reuse_counts": { + "vision": 1, + "language": 8, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "deb3cc137c72ac7e023b78a4d29d507ddf95f02f2572e38dd068a3574116ac21" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "cc047cd8ed2d1ddd4493abd7cff8ee7ba9fcd0b6265e1a1b8b4b2f6c6e822390" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "6fd0e47d02ff77335d5b2733962a9f7a1caed5ea867aa67b8c3b4b788509dba1" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "c0e9e08d7a1863b1e91cca10457d593e1281ccd5695cfb89683b8121826cff38" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8de01e028cd92e75ba21cf901916223dc844a7c580f8bb2b943828403cb28198" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "eb7ea7dd8487457bc025d44ba5ebc1550026250abea05f847d61b8ea6f52af8e" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "60b6d77d34ada12b8def875237be8cd0feee4475ccf4cb389bd44245b21a8f9d" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "0d717f46abbc57e2696c66d4969fc777e96415a6f67740a7087cf77d78de218d" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "ff71ef4e6c311c56cd3dbe484f8a05773dba0361b21e97745ca7394758319d1c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cb1f6fae46aaeb1f6b21beafd94e066b87b0bd4a02e7f10bf6f0e991cbc43f49" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 460, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0472dbfc0ad390d48f2d4340f8688dfb77298cede625d8d070c3ec3648cd712b" + }, + "position_ids": { + "shape": [ + 3, + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "506ff79aaba73a3bd70f9b1fac38badd9497de8377e2db255b1322b7ae308b86" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "a075316b24c03cafe09f612e8c4499e0c87035b098bf3db6f8023f7be18c405d" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 469, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "fecbffc833f744dd32c6b0296b399ef7256ded521c75fd8a5dfb2fd6f5e3c762" + }, + "position_ids": { + "shape": [ + 3, + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "a679452a2039eff05da911d8657b1857f058184d4bb373cd35576f7d3bfca410" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 752, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cd572e59171ef52d8e37644cbbdbbf9ff86d77d31cf48b19c4821d7349c026f7" + }, + "position_ids": { + "shape": [ + 3, + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "3d615db0cf3b07f33f32c5d24335f9abdd5b4599e5de79b20326f339520128d1" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 426, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "b464ff04b79496dcab96f3a8b588a4bc5e611075d4e44ff7b526eaa685658b4a" + }, + "position_ids": { + "shape": [ + 3, + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "edacad438038fb1d85e9097dd2de086c8f14696351353792f13df88e99e9de7b" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 442, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "db88bedddbbd1d2b6aaf63664379d5206b0de9ef3fcf0ccdd0fb951599364847" + }, + "position_ids": { + "shape": [ + 3, + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "f706ff63624d02735d39ebe7097dc53d833763276475713d80259d5fed6d7446" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 443, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "c108e3059ad63ab2efd4d2d194766ab18ef6144819985ff6448dae85f476b032" + }, + "position_ids": { + "shape": [ + 3, + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "9e4fd6391bea467b1a278b2506d278b0ae583fc15a686a31882dc377374e04d1" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q8": { + "type": "choice", + "choice": "leave", + "probabilities": { + "stay": 0.01798621006309986, + "leave": 0.9820137619972229 + }, + "confidence": 0.8700206851739604 + }, + "q7": { + "type": "choice", + "choice": "yes", + "probabilities": { + "yes": 0.9823379516601562, + "no": 0.0035428637638688087, + "wait": 0.006618940737098455, + "help": 0.007500242441892624 + }, + "confidence": 0.9225223144825633 + }, + "q6": { + "type": "choice", + "choice": "first", + "probabilities": { + "first": 0.531209409236908, + "second": 0.4687906503677368 + }, + "confidence": 0.002812297157495758 + }, + "q5": { + "type": "choice", + "choice": "object", + "probabilities": { + "null": 0.07443060725927353, + "object": 0.9067503809928894, + "array": 0.01881900243461132 + }, + "confidence": 0.6751463333759231 + }, + "q4": { + "type": "choice", + "choice": "option-3", + "probabilities": { + "option-0": 0.07546718418598175, + "option-1": 0.00034948240499943495, + "option-2": 0.263406366109848, + "option-3": 0.557631254196167, + "option-4": 0.009013270027935505, + "option-5": 0.01908109337091446, + "option-6": 0.007019542157649994, + "option-7": 0.016839005053043365, + "option-8": 0.009013270027935505, + "option-9": 0.0025823453906923532, + "option-10": 0.004824455827474594, + "option-11": 0.003315796609967947, + "option-12": 0.002011132426559925, + "option-13": 0.0022789116483181715, + "option-14": 0.00619472423568368, + "option-15": 0.0010764816543087363, + "option-16": 0.0037572900764644146, + "option-17": 0.0006529190577566624, + "option-18": 0.002011132426559925, + "option-19": 0.0012198134791105986, + "option-20": 0.00044874430750496686, + "option-21": 0.0005084939184598625, + "option-22": 0.003315796609967947, + "option-23": 0.0013822298496961594, + "option-24": 0.0017748181708157063, + "option-25": 0.004824455827474594 + }, + "confidence": 0.5755459268738158 + }, + "q3": { + "type": "choice", + "choice": "only", + "probabilities": { + "only": 1.0 + }, + "confidence": 1.0 + }, + "q2": { + "type": "choice", + "choice": "cancel", + "probabilities": { + "cancel": 0.9995121955871582, + "save": 0.00048785717808641493 + }, + "confidence": 0.9939293781678539 + }, + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.998498797416687, + "cancel": 0.0015011822106316686 + }, + "confidence": 0.9837552323853659 + } + }, + "usage": { + "input_tokens": 3874, + "output_tokens": 0 + } + } + }, + { + "id": "distinct-small-image", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 8, + "language": 8, + "image_preprocess": 8 + }, + "reuse_counts": { + "vision": 1, + "language": 8, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 223 + ], + "dtype": "torch.int64", + "sha256": "9d7231a5a328a6cd012a665bedf8b65524e30d729aa2871f4f9d7d8d6b9cd99d" + }, + "attention_mask": { + "shape": [ + 1, + 223 + ], + "dtype": "torch.int64", + "sha256": "37f69a92ed5107c51231eb10a952d103922d8737a5ef14678508b68c6a0beabe" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 223 + ], + "dtype": "torch.int64", + "sha256": "1e0ebc653eddfe88d9b9399061a632e9741008379b0bc9bb21f2d825c84a2ac2" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 222 + ], + "dtype": "torch.int64", + "sha256": "3953aac266172f9ee29c3cdc862a4c1e6831cb30240cf5b1824a2b31757d0fb5" + }, + "attention_mask": { + "shape": [ + 1, + 222 + ], + "dtype": "torch.int64", + "sha256": "c301bfbcb26c5293c6f1688ca3df34437ba6d32cc807b1d5bd6d0b4bdf8ca3ba" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 222 + ], + "dtype": "torch.int64", + "sha256": "94fac1acc4e527d6c414b62ca2c6c440be1c4a37810ddcbf7014938b2b2461f3" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 206 + ], + "dtype": "torch.int64", + "sha256": "feed65e7bcc5bda2a74af03514af5376d988fbb50ca53dd338e0b9e52efee57e" + }, + "attention_mask": { + "shape": [ + 1, + 206 + ], + "dtype": "torch.int64", + "sha256": "030a7d06a97c8b65c7e8da52911bf7aea1d2ca41a430efdec0e761c35ecb1e87" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 206 + ], + "dtype": "torch.int64", + "sha256": "61d5f846b6c4f6638e29a11024c6574e6d20ec905a7beabc225d5d2dda739e4c" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 532 + ], + "dtype": "torch.int64", + "sha256": "bac1ece493846e52ef6ddc33ccab1954bab98d9fe1472be3e082d8e1b92c0fd1" + }, + "attention_mask": { + "shape": [ + 1, + 532 + ], + "dtype": "torch.int64", + "sha256": "45f71924adcefcfa5208a0224cb17f075f80f4e256eded175a42783fbb38be09" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 532 + ], + "dtype": "torch.int64", + "sha256": "77598fb85ff6712e7e4a3f7e8dbdb4ff1f289f17cd0f8b4bfd0ce20f8a9a2c20" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 249 + ], + "dtype": "torch.int64", + "sha256": "616f3a69d07c5bf9b5d9264efb0c0205c19aee13849e19225817659584ea62ae" + }, + "attention_mask": { + "shape": [ + 1, + 249 + ], + "dtype": "torch.int64", + "sha256": "5772cc13dfa52a6436735810cb716e07c836d807b5bedd759987c17ae4d83e1b" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 249 + ], + "dtype": "torch.int64", + "sha256": "cb0537d81f5c85e6a2ae3a7a6891e9a09564f4be2eb5e05be362fc0075d2cec1" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "8f822829d3790bd753a4321d2aa9381615fd2db65cf613a72ad551aa0cf67ab5" + }, + "attention_mask": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "17f64dedf022d9f1c7bb515e639804af287f302776401979221a1aa146a2ca92" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "14e7e638809cb581b6591752a143d6f3420807408f17b67202b40e9b408c4963" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 240 + ], + "dtype": "torch.int64", + "sha256": "fc53d3218c5edc7db677a8d8f812139a6381064ae9a4a510a7b4ecbd37cb58f0" + }, + "attention_mask": { + "shape": [ + 1, + 240 + ], + "dtype": "torch.int64", + "sha256": "e4eaaa8d2ab4d56a946886f95e7fa6865cb411a3e34985d6651eb35c4e0eff0d" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 240 + ], + "dtype": "torch.int64", + "sha256": "71e9ca6442dc33ff58c57959f7f0f61aa6ef1e9c2fee04f9af98824bacd449ae" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + }, + { + "input_ids": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "a287f00ea6301930d67b9827a5d8b9732643300a838e1e8e42f6a6d9d2212a41" + }, + "attention_mask": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "17f64dedf022d9f1c7bb515e639804af287f302776401979221a1aa146a2ca92" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "14e7e638809cb581b6591752a143d6f3420807408f17b67202b40e9b408c4963" + }, + "pixel_values": { + "shape": [ + 320, + 1536 + ], + "dtype": "torch.float32", + "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 223, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "a7518273b9a87818edea8021f6210434d4dcd43cb0a31040d93e402ed8e4327d" + }, + "position_ids": { + "shape": [ + 3, + 1, + 223 + ], + "dtype": "torch.int64", + "sha256": "4acc9b9832ab208fb2f6236c91f3fa9a9888c0c60299e9633f5906c703e5dbf3" + }, + "attention_mask": { + "shape": [ + 1, + 223 + ], + "dtype": "torch.int64", + "sha256": "37f69a92ed5107c51231eb10a952d103922d8737a5ef14678508b68c6a0beabe" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 222, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "505ee754d85f0c2f50dedb849324b790b573ac4d3796a29399af909e4a535264" + }, + "position_ids": { + "shape": [ + 3, + 1, + 222 + ], + "dtype": "torch.int64", + "sha256": "d508e8173eddb4367dcff2e034b9e660da9468ecfa127f974a9f24937cdd8308" + }, + "attention_mask": { + "shape": [ + 1, + 222 + ], + "dtype": "torch.int64", + "sha256": "c301bfbcb26c5293c6f1688ca3df34437ba6d32cc807b1d5bd6d0b4bdf8ca3ba" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 206, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "f9f37805b6e53077164e2bb8a0706c2177d8afa32dec2c2202720aa44127aa30" + }, + "position_ids": { + "shape": [ + 3, + 1, + 206 + ], + "dtype": "torch.int64", + "sha256": "9da5fa04c7cac86c61d6009005d7d5baf8ecd59dde2c91510aa53f770377dd37" + }, + "attention_mask": { + "shape": [ + 1, + 206 + ], + "dtype": "torch.int64", + "sha256": "030a7d06a97c8b65c7e8da52911bf7aea1d2ca41a430efdec0e761c35ecb1e87" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 532, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "81669f0ce1bcc6736decc0a87f3dbc1c7b2cf79a77208406a82b18cf3d0afe0c" + }, + "position_ids": { + "shape": [ + 3, + 1, + 532 + ], + "dtype": "torch.int64", + "sha256": "abb8b32ebad69693806dc6ec043b8b3cb88fd452fef624179bbdd084fd6f9420" + }, + "attention_mask": { + "shape": [ + 1, + 532 + ], + "dtype": "torch.int64", + "sha256": "45f71924adcefcfa5208a0224cb17f075f80f4e256eded175a42783fbb38be09" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 249, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "13b2aed945654c35c370e960c9acc2b4388f064fac347b19b0e2cebdea1ee4a5" + }, + "position_ids": { + "shape": [ + 3, + 1, + 249 + ], + "dtype": "torch.int64", + "sha256": "b0039549be2532f6971c4b58be875cd190cee0ed7c09fe187c51e8aab94c045a" + }, + "attention_mask": { + "shape": [ + 1, + 249 + ], + "dtype": "torch.int64", + "sha256": "5772cc13dfa52a6436735810cb716e07c836d807b5bedd759987c17ae4d83e1b" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 221, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "1c27841fdfad3529853fe147f72a5728b936284b6c2f5df403856af9312e6182" + }, + "position_ids": { + "shape": [ + 3, + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "2a2d4966fa57bf1b9d34ad6ce5b06e03bf2a085bc134d66da2509b95730be49e" + }, + "attention_mask": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "17f64dedf022d9f1c7bb515e639804af287f302776401979221a1aa146a2ca92" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 240, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "2aa99bf2579a64e805fb0dc9952b4f70f00f04f46c9768b6f3138fe44080382b" + }, + "position_ids": { + "shape": [ + 3, + 1, + 240 + ], + "dtype": "torch.int64", + "sha256": "93e979c91a7902ba7378c79c62473a4749b7f7542abd12b1a010733217c90a93" + }, + "attention_mask": { + "shape": [ + 1, + 240 + ], + "dtype": "torch.int64", + "sha256": "e4eaaa8d2ab4d56a946886f95e7fa6865cb411a3e34985d6651eb35c4e0eff0d" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 221, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "d8c5640ae7f95fc64b7920656cd3465c4cbf22a5ed617cb886a71345a35470d8" + }, + "position_ids": { + "shape": [ + 3, + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "2a2d4966fa57bf1b9d34ad6ce5b06e03bf2a085bc134d66da2509b95730be49e" + }, + "attention_mask": { + "shape": [ + 1, + 221 + ], + "dtype": "torch.int64", + "sha256": "17f64dedf022d9f1c7bb515e639804af287f302776401979221a1aa146a2ca92" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9978172779083252, + "cancel": 0.002182716503739357 + }, + "confidence": 0.9775599661366724 + }, + "q2": { + "type": "choice", + "choice": "cancel", + "probabilities": { + "cancel": 0.9990890026092529, + "save": 0.0009110512328334153 + }, + "confidence": 0.9894845258048839 + }, + "q3": { + "type": "choice", + "choice": "only", + "probabilities": { + "only": 1.0 + }, + "confidence": 1.0 + }, + "q4": { + "type": "choice", + "choice": "option-2", + "probabilities": { + "option-0": 0.06260567903518677, + "option-1": 0.0002899218525271863, + "option-2": 0.5939862132072449, + "option-3": 0.24761027097702026, + "option-4": 0.009600892663002014, + "option-5": 0.015829196199774742, + "option-6": 0.00659859087318182, + "option-7": 0.015829196199774742, + "option-8": 0.007477182894945145, + "option-9": 0.0016683851135894656, + "option-10": 0.003116953419521451, + "option-11": 0.0035319707822054625, + "option-12": 0.0024274857714772224, + "option-13": 0.0024274857714772224, + "option-14": 0.007477182894945145, + "option-15": 0.001011926680803299, + "option-16": 0.0024274857714772224, + "option-17": 0.0007880892371758819, + "option-18": 0.001890527899377048, + "option-19": 0.001472344622015953, + "option-20": 0.00042183377081528306, + "option-21": 0.000541645276825875, + "option-22": 0.004535140469670296, + "option-23": 0.001011926680803299, + "option-24": 0.001890527899377048, + "option-25": 0.0035319707822054625 + }, + "confidence": 0.5978649242508383 + }, + "q5": { + "type": "choice", + "choice": "object", + "probabilities": { + "null": 0.0662643164396286, + "object": 0.9147506356239319, + "array": 0.018985042348504066 + }, + "confidence": 0.6936001429109977 + }, + "q6": { + "type": "choice", + "choice": "second", + "probabilities": { + "first": 0.3775406777858734, + "second": 0.622459352016449 + }, + "confidence": 0.04371347674840487 + }, + "q7": { + "type": "choice", + "choice": "yes", + "probabilities": { + "yes": 0.9805492758750916, + "no": 0.004007280804216862, + "wait": 0.0058305589482188225, + "help": 0.009612967260181904 + }, + "confidence": 0.9163063661161868 + }, + "q8": { + "type": "choice", + "choice": "leave", + "probabilities": { + "stay": 0.01243165135383606, + "leave": 0.9875683188438416 + }, + "confidence": 0.9034864798488087 + } + }, + "usage": { + "input_tokens": 2114, + "output_tokens": 0 + } + } + }, + { + "id": "distinct-original-again", + "exact_prepared_tensor_parity": true, + "exact_response_parity": true, + "exact_language_input_parity": true, + "baseline_counts": { + "vision": 8, + "language": 8, + "image_preprocess": 8 + }, + "reuse_counts": { + "vision": 1, + "language": 8, + "image_preprocess": 1 + }, + "inputs": [ + { + "input_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "0d717f46abbc57e2696c66d4969fc777e96415a6f67740a7087cf77d78de218d" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "ff71ef4e6c311c56cd3dbe484f8a05773dba0361b21e97745ca7394758319d1c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "eb7ea7dd8487457bc025d44ba5ebc1550026250abea05f847d61b8ea6f52af8e" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "60b6d77d34ada12b8def875237be8cd0feee4475ccf4cb389bd44245b21a8f9d" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "c0e9e08d7a1863b1e91cca10457d593e1281ccd5695cfb89683b8121826cff38" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8de01e028cd92e75ba21cf901916223dc844a7c580f8bb2b943828403cb28198" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "cc047cd8ed2d1ddd4493abd7cff8ee7ba9fcd0b6265e1a1b8b4b2f6c6e822390" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "6fd0e47d02ff77335d5b2733962a9f7a1caed5ea867aa67b8c3b4b788509dba1" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + }, + { + "input_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "deb3cc137c72ac7e023b78a4d29d507ddf95f02f2572e38dd068a3574116ac21" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + }, + "mm_token_type_ids": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" + }, + "pixel_values": { + "shape": [ + 1200, + 1536 + ], + "dtype": "torch.float32", + "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" + }, + "image_grid_thw": { + "shape": [ + 1, + 3 + ], + "dtype": "torch.int64", + "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" + } + } + ], + "language_inputs": [ + { + "inputs_embeds": { + "shape": [ + 1, + 443, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "c108e3059ad63ab2efd4d2d194766ab18ef6144819985ff6448dae85f476b032" + }, + "position_ids": { + "shape": [ + 3, + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "9e4fd6391bea467b1a278b2506d278b0ae583fc15a686a31882dc377374e04d1" + }, + "attention_mask": { + "shape": [ + 1, + 443 + ], + "dtype": "torch.int64", + "sha256": "c750984facbba9cc203c2063c1625a4d724554f41a9e597b8ccf719ab5ed0f65" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 442, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "db88bedddbbd1d2b6aaf63664379d5206b0de9ef3fcf0ccdd0fb951599364847" + }, + "position_ids": { + "shape": [ + 3, + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "f706ff63624d02735d39ebe7097dc53d833763276475713d80259d5fed6d7446" + }, + "attention_mask": { + "shape": [ + 1, + 442 + ], + "dtype": "torch.int64", + "sha256": "ff82267dd987206b6de104e81e571f9fee5e056405c834078ac117676e801f0d" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 426, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "b464ff04b79496dcab96f3a8b588a4bc5e611075d4e44ff7b526eaa685658b4a" + }, + "position_ids": { + "shape": [ + 3, + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "edacad438038fb1d85e9097dd2de086c8f14696351353792f13df88e99e9de7b" + }, + "attention_mask": { + "shape": [ + 1, + 426 + ], + "dtype": "torch.int64", + "sha256": "8d542037e82d3d9428d7a56f9e974de93bf46c0d14ffe9aaf2fca9d8d6d72750" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 752, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cd572e59171ef52d8e37644cbbdbbf9ff86d77d31cf48b19c4821d7349c026f7" + }, + "position_ids": { + "shape": [ + 3, + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "3d615db0cf3b07f33f32c5d24335f9abdd5b4599e5de79b20326f339520128d1" + }, + "attention_mask": { + "shape": [ + 1, + 752 + ], + "dtype": "torch.int64", + "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 469, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "fecbffc833f744dd32c6b0296b399ef7256ded521c75fd8a5dfb2fd6f5e3c762" + }, + "position_ids": { + "shape": [ + 3, + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "a679452a2039eff05da911d8657b1857f058184d4bb373cd35576f7d3bfca410" + }, + "attention_mask": { + "shape": [ + 1, + 469 + ], + "dtype": "torch.int64", + "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "a075316b24c03cafe09f612e8c4499e0c87035b098bf3db6f8023f7be18c405d" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 460, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "0472dbfc0ad390d48f2d4340f8688dfb77298cede625d8d070c3ec3648cd712b" + }, + "position_ids": { + "shape": [ + 3, + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "506ff79aaba73a3bd70f9b1fac38badd9497de8377e2db255b1322b7ae308b86" + }, + "attention_mask": { + "shape": [ + 1, + 460 + ], + "dtype": "torch.int64", + "sha256": "8ac2e87ef950a105d953100ed1bf123ce767777ded6acb77a112cc67593aa3ed" + } + }, + { + "inputs_embeds": { + "shape": [ + 1, + 441, + 2560 + ], + "dtype": "torch.bfloat16", + "sha256": "cb1f6fae46aaeb1f6b21beafd94e066b87b0bd4a02e7f10bf6f0e991cbc43f49" + }, + "position_ids": { + "shape": [ + 3, + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "73977987448e9057abd0c27191d4d3979341206cb869512bb11059aead59538e" + }, + "attention_mask": { + "shape": [ + 1, + 441 + ], + "dtype": "torch.int64", + "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" + } + } + ], + "response": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.998498797416687, + "cancel": 0.0015011822106316686 + }, + "confidence": 0.9837552323853659 + }, + "q2": { + "type": "choice", + "choice": "cancel", + "probabilities": { + "cancel": 0.9995121955871582, + "save": 0.00048785717808641493 + }, + "confidence": 0.9939293781678539 + }, + "q3": { + "type": "choice", + "choice": "only", + "probabilities": { + "only": 1.0 + }, + "confidence": 1.0 + }, + "q4": { + "type": "choice", + "choice": "option-3", + "probabilities": { + "option-0": 0.07546718418598175, + "option-1": 0.00034948240499943495, + "option-2": 0.263406366109848, + "option-3": 0.557631254196167, + "option-4": 0.009013270027935505, + "option-5": 0.01908109337091446, + "option-6": 0.007019542157649994, + "option-7": 0.016839005053043365, + "option-8": 0.009013270027935505, + "option-9": 0.0025823453906923532, + "option-10": 0.004824455827474594, + "option-11": 0.003315796609967947, + "option-12": 0.002011132426559925, + "option-13": 0.0022789116483181715, + "option-14": 0.00619472423568368, + "option-15": 0.0010764816543087363, + "option-16": 0.0037572900764644146, + "option-17": 0.0006529190577566624, + "option-18": 0.002011132426559925, + "option-19": 0.0012198134791105986, + "option-20": 0.00044874430750496686, + "option-21": 0.0005084939184598625, + "option-22": 0.003315796609967947, + "option-23": 0.0013822298496961594, + "option-24": 0.0017748181708157063, + "option-25": 0.004824455827474594 + }, + "confidence": 0.5755459268738158 + }, + "q5": { + "type": "choice", + "choice": "object", + "probabilities": { + "null": 0.07443060725927353, + "object": 0.9067503809928894, + "array": 0.01881900243461132 + }, + "confidence": 0.6751463333759231 + }, + "q6": { + "type": "choice", + "choice": "first", + "probabilities": { + "first": 0.531209409236908, + "second": 0.4687906503677368 + }, + "confidence": 0.002812297157495758 + }, + "q7": { + "type": "choice", + "choice": "yes", + "probabilities": { + "yes": 0.9823379516601562, + "no": 0.0035428637638688087, + "wait": 0.006618940737098455, + "help": 0.007500242441892624 + }, + "confidence": 0.9225223144825633 + }, + "q8": { + "type": "choice", + "choice": "leave", + "probabilities": { + "stay": 0.01798621006309986, + "leave": 0.9820137619972229 + }, + "confidence": 0.8700206851739604 + } + }, + "usage": { + "input_tokens": 3874, + "output_tokens": 0 + } + } + } + ], + "cases": [], + "environment": { + "python": "3.12.13", + "gpu": "NVIDIA GeForce RTX 4090", + "compute_capability": [ + 8, + 9 + ], + "cuda": "13.0", + "driver": "595.71.05", + "torch_num_threads": 64, + "torch_num_interop_threads": 64, + "packages": { + "torch": "2.14.0", + "torchvision": "0.29.0", + "transformers": "5.17.0", + "peft": "0.21.0", + "pillow": "11.3.0", + "safetensors": "0.8.0", + "triton": "3.8.0" + }, + "reference_revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f", + "base_revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", + "adapter_revision": "16818868b0cc7813808aae4e87b417657046ab79", + "dtype": "bfloat16", + "adapter_merged": false + }, + "load_ms": 19145.926974713802, + "adapter_modules": 178 +} diff --git a/recipe/cua_s1/experiments/rtx4090-last-logits/correctness.log b/recipe/cua_s1/experiments/rtx4090-last-logits/correctness.log new file mode 100644 index 0000000..0d2561e --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-last-logits/correctness.log @@ -0,0 +1,17 @@ +[transformers] `torch_dtype` is deprecated! Use `dtype` instead! + Loading weights: 0%| | 0/723 [00:00 Device)", + "device_type": "DeviceType.CUDA", + "count": 51, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1520.50899999994, + "annotation": false + }, + { + "op": "cudaStreamSynchronize", + "device_type": "DeviceType.CPU", + "count": 247, + "input_shapes": [], + "cpu_us": 35553.99199999998, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 10, + "input_shapes": [ + [ + 1, + 3 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 20.65400000025693, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 10, + "input_shapes": [ + [ + 1, + 3 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 36.006999999677646, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 10, + "input_shapes": [ + [ + 1, + 3 + ], + [ + 1, + 3 + ], + [] + ], + "cpu_us": 44.08700000009412, + "gpu_us": 4.13000000005195, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 1536 + ], + [], + [], + [], + [] + ], + "cpu_us": 1.8000000000029104, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "cudaLaunchKernel", + "device_type": "DeviceType.CPU", + "count": 48177, + "input_shapes": [], + "cpu_us": 222924.30299998386, + "gpu_us": 0, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::bfloat16_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda(float)#1}, std::array, false>(int, at::native::bfloat16_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 2172, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 7748.695000002412, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 3, + "input_shapes": [ + [ + 1 + ], + [ + 1 + ] + ], + "cpu_us": 32.92800000000352, + "gpu_us": 3.2659999999996217, + "annotation": false + }, + { + "op": "void at::native::unrolled_elementwise_kernel >, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast>(int, at::native::BinaryFunctor >, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast)", + "device_type": "DeviceType.CUDA", + "count": 2, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 2.1450000000004366, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::BinaryFunctor >, std::array, false>(int, at::native::BinaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "count": 2, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 2.2739999999976135, + "annotation": false + }, + { + "op": "aten::repeat_interleave", + "device_type": "DeviceType.CPU", + "count": 4, + "input_shapes": [ + [ + 1 + ], + [ + 1 + ], + [], + [] + ], + "cpu_us": 39.12300000000323, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::flatten", + "device_type": "DeviceType.CPU", + "count": 4, + "input_shapes": [ + [ + 1 + ], + [], + [] + ], + "cpu_us": 1.194999999996071, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 4, + "input_shapes": [ + [ + 1 + ], + [] + ], + "cpu_us": 5.496000000006461, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 1 + ], + [] + ], + "cpu_us": 22.397000000179105, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 5, + "input_shapes": [ + [ + 1 + ], + [], + [] + ], + "cpu_us": 15.836999999995896, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 23, + "input_shapes": [ + [ + 1 + ], + [], + [], + [] + ], + "cpu_us": 18.348999999951047, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::repeat_interleave", + "device_type": "DeviceType.CPU", + "count": 4, + "input_shapes": [ + [ + 1 + ], + [] + ], + "cpu_us": 79.02399999999034, + "gpu_us": 5.316000000002532, + "annotation": false + }, + { + "op": "aten::cumsum", + "device_type": "DeviceType.CPU", + "count": 6, + "input_shapes": [ + [ + 1 + ], + [], + [] + ], + "cpu_us": 135.1149999999834, + "gpu_us": 12.905000000006112, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 6, + "input_shapes": [ + [ + 1 + ], + [], + [], + [], + [] + ], + "cpu_us": 3.1530000000057044, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "cudaPeekAtLastError", + "device_type": "DeviceType.CPU", + "count": 202, + "input_shapes": [], + "cpu_us": 22.680000000011205, + "gpu_us": 0, + "annotation": false + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceScanInitKernel >(at_cuda_detail::cub::ScanTileState, int)", + "device_type": "DeviceType.CUDA", + "count": 13, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 10.757999999936146, + "annotation": false + }, + { + "op": "cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags", + "device_type": "DeviceType.CPU", + "count": 14, + "input_shapes": [], + "cpu_us": 33.86700000009296, + "gpu_us": 0, + "annotation": false + }, + { + "op": "cudaDeviceGetAttribute", + "device_type": "DeviceType.CPU", + "count": 486, + "input_shapes": [], + "cpu_us": 376.0399999999863, + "gpu_us": 0, + "annotation": false + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceScanKernel >::Policy1000, long const*, long*, at_cuda_detail::cub::ScanTileState, std::plus, at_cuda_detail::cub::NullType, unsigned int, long, false, at_cuda_detail::cub::NullType>(long const*, long*, at_cuda_detail::cub::ScanTileState, int, std::plus, at_cuda_detail::cub::NullType, unsigned int)", + "device_type": "DeviceType.CUDA", + "count": 5, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 6.532999999995809, + "annotation": false + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "count": 4, + "input_shapes": [ + [ + 1 + ], + [], + [] + ], + "cpu_us": 8.330000000001746, + "gpu_us": 0, + "annotation": false + }, + { + "op": "Memcpy DtoH (Device -> Pinned)", + "device_type": "DeviceType.CUDA", + "count": 105, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 93.88900000027934, + "annotation": false + }, + { + "op": "aten::ge", + "device_type": "DeviceType.CPU", + "count": 4, + "input_shapes": [ + [ + 1 + ], + [] + ], + "cpu_us": 45.824000000000524, + "gpu_us": 4.063999999998487, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::compare_scalar_kernel(at::TensorIteratorBase&, at::native::(anonymous namespace)::OpType, long)::{lambda(long)#1}, std::array, false>(int, at::native::compare_scalar_kernel(at::TensorIteratorBase&, at::native::(anonymous namespace)::OpType, long)::{lambda(long)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 4, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 4.063999999998487, + "annotation": false + }, + { + "op": "aten::all", + "device_type": "DeviceType.CPU", + "count": 4, + "input_shapes": [ + [ + 1 + ] + ], + "cpu_us": 32.348000000001775, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::view_as", + "device_type": "DeviceType.CPU", + "count": 4, + "input_shapes": [ + [ + 1 + ], + [] + ], + "cpu_us": 5.708000000002357, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 12, + "input_shapes": [ + [], + [], + [], + [], + [] + ], + "cpu_us": 2.8169999998499407, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 12, + "input_shapes": [ + [], + [], + [] + ], + "cpu_us": 42.61099999995349, + "gpu_us": 11.943000000188476, + "annotation": false + }, + { + "op": "Memcpy DtoD (Device -> Device)", + "device_type": "DeviceType.CUDA", + "count": 432, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1025.8630000022822, + "annotation": false + }, + { + "op": "void compute_cuda_kernel(long const*, long const*, long*, long, long)", + "device_type": "DeviceType.CUDA", + "count": 4, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 5.316000000002532, + "annotation": false + }, + { + "op": "aten::index_select", + "device_type": "DeviceType.CPU", + "count": 3, + "input_shapes": [ + [ + 1 + ], + [], + [ + 1200 + ] + ], + "cpu_us": 36.77300000000105, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::resize_", + "device_type": "DeviceType.CPU", + "count": 1429, + "input_shapes": [ + [ + 0 + ], + [], + [] + ], + "cpu_us": 5321.510999997223, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 101, + "input_shapes": [ + [ + 1200 + ], + [] + ], + "cpu_us": 54.5530000000399, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 3, + "input_shapes": [ + [ + 1200 + ], + [], + [] + ], + "cpu_us": 5.0349999999998545, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 14, + "input_shapes": [ + [ + 1200 + ], + [], + [], + [] + ], + "cpu_us": 6.399000000004889, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::gather", + "device_type": "DeviceType.CPU", + "count": 3, + "input_shapes": [ + [ + 1 + ], + [], + [ + 1200 + ], + [], + [ + 1200 + ] + ], + "cpu_us": 31.016000000006898, + "gpu_us": 8.165000000000873, + "annotation": false + }, + { + "op": "void at::native::_scatter_gather_elementwise_kernel<128, 8, at::native::_cuda_scatter_gather_internal_kernel, long>::operator()(at::TensorIterator&, long, long, long, at::native::TensorAssign const&)::{lambda(int)#1}>(int, at::native::_cuda_scatter_gather_internal_kernel, long>::operator()(at::TensorIterator&, long, long, long, at::native::TensorAssign const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 3, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 8.165000000000873, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1 + ], + [], + [], + [], + [] + ], + "cpu_us": 7.9539999999979045, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::pad", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 0 + ], + [], + [], + [] + ], + "cpu_us": 3.9030000000020664, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::constant_pad_nd", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 0 + ], + [], + [] + ], + "cpu_us": 8.4729999999945, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::FillFunctor, std::array, false>(int, at::native::FillFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "count": 9, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 8.228000000177417, + "annotation": false + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1 + ], + [], + [], + [] + ], + "cpu_us": 2.8040000000000873, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 129, + "input_shapes": [ + [ + 0 + ], + [ + 0 + ], + [] + ], + "cpu_us": 126.69500000051994, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::sum", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1 + ], + [] + ], + "cpu_us": 18.751000000000204, + "gpu_us": 1.9210000000020955, + "annotation": false + }, + { + "op": "void at::native::reduce_kernel<512, 1, at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(long, long)#1}>, unsigned int, long, 4, 4> >(at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(long, long)#1}>, unsigned int, long, 4, 4>)", + "device_type": "DeviceType.CUDA", + "count": 25, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 49.56800000031217, + "annotation": false + }, + { + "op": "aten::arange", + "device_type": "DeviceType.CPU", + "count": 44, + "input_shapes": [ + [], + [], + [], + [], + [] + ], + "cpu_us": 248.26099999919825, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::arange", + "device_type": "DeviceType.CPU", + "count": 814, + "input_shapes": [ + [], + [], + [], + [ + 0 + ] + ], + "cpu_us": 4504.760000002407, + "gpu_us": 682.5479999974086, + "annotation": false + }, + { + "op": "void (anonymous namespace)::elementwise_kernel_with_index(int, at::native::arange_cuda_out(c10::Scalar const&, c10::Scalar const&, c10::Scalar const&, at::Tensor&)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}, function_traits::result_type*)", + "device_type": "DeviceType.CUDA", + "count": 813, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 682.5479999974086, + "annotation": false + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ], + [] + ], + "cpu_us": 13.316000000002532, + "gpu_us": 1.2489999999997963, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::CUDAFunctor_add, std::array, false>(int, at::native::CUDAFunctor_add, std::array)", + "device_type": "DeviceType.CUDA", + "count": 3, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 3.617999999998574, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ] + ], + "cpu_us": 7.593000000000757, + "gpu_us": 1.1529999999984284, + "annotation": false + }, + { + "op": "aten::remainder", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ] + ], + "cpu_us": 20.97200000000157, + "gpu_us": 3.2340000000003783, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::BinaryFunctor, std::array, false>(int, at::native::BinaryFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "count": 2, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 3.2340000000003783, + "annotation": false + }, + { + "op": "aten::floor_divide", + "device_type": "DeviceType.CPU", + "count": 3, + "input_shapes": [ + [ + 1200 + ], + [] + ], + "cpu_us": 22.875, + "gpu_us": 5.4430000000029395, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::BUnaryFunctor, std::array, false>(int, at::native::BUnaryFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "count": 12, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 18.025000000034197, + "annotation": false + }, + { + "op": "aten::remainder", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200 + ], + [] + ], + "cpu_us": 23.305999999996857, + "gpu_us": 3.138999999999214, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::BUnaryFunctor, std::array, false>(int, at::native::BUnaryFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "count": 2, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 3.138999999999214, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 5, + "input_shapes": [ + [ + 1200 + ], + [] + ], + "cpu_us": 37.818999999999505, + "gpu_us": 5.283000000003085, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::AUnaryFunctor >, std::array, false>(int, at::native::AUnaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "count": 20, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 21.42099999983111, + "annotation": false + }, + { + "op": "aten::floor_divide", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ] + ], + "cpu_us": 8.067999999999302, + "gpu_us": 2.2739999999976135, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::BinaryFunctor, std::array, false>(int, at::native::BinaryFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "count": 1, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 2.2739999999976135, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ], + [] + ], + "cpu_us": 15.70400000000518, + "gpu_us": 2.3689999999987776, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 6, + "input_shapes": [ + [ + 1200 + ], + [], + [], + [], + [] + ], + "cpu_us": 6.2629999999953725, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 4, + "input_shapes": [ + [ + 1200 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 16.450000000000728, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 4, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ], + [] + ], + "cpu_us": 25.87399999999252, + "gpu_us": 7.812999999998283, + "annotation": false + }, + { + "op": "void at::native::unrolled_elementwise_kernel, 4, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1> >(int, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "count": 3093, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 13343.530000008068, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::AUnaryFunctor >, std::array, false>(int, at::native::AUnaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "count": 1286, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 8156.365000001715, + "annotation": false + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200 + ], + [], + [] + ], + "cpu_us": 15.919000000001688, + "gpu_us": 2.24199999999837, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::CUDAFunctorOnSelf_add, std::array, false>(int, at::native::CUDAFunctorOnSelf_add, std::array)", + "device_type": "DeviceType.CUDA", + "count": 58, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 58.660999999789055, + "annotation": false + }, + { + "op": "aten::clamp", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200 + ], + [], + [] + ], + "cpu_us": 27.568000000010215, + "gpu_us": 2.2410000000018044, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<2, at::native::(anonymous namespace)::launch_clamp_scalar(at::TensorIteratorBase&, c10::Scalar, c10::Scalar, at::native::detail::ClampLimits)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}, std::array, false>(int, at::native::(anonymous namespace)::launch_clamp_scalar(at::TensorIteratorBase&, c10::Scalar, c10::Scalar, at::native::detail::ClampLimits)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 4, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 4.547000000005937, + "annotation": false + }, + { + "op": "aten::div", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200 + ], + [ + 1200 + ] + ], + "cpu_us": 20.650000000001455, + "gpu_us": 5.186999999998079, + "annotation": false + }, + { + "op": "void at::native::unrolled_elementwise_kernel >, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1> >(int, at::native::BinaryFunctor >, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "count": 2, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 5.186999999998079, + "annotation": false + }, + { + "op": "aten::floor", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200 + ] + ], + "cpu_us": 20.816999999999098, + "gpu_us": 2.0160000000032596, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::floor_kernel_cuda(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::floor_kernel_cuda(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 2, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 2.0160000000032596, + "annotation": false + }, + { + "op": "aten::arange", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 6.9539999999942665, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "void at::native::unrolled_elementwise_kernel, 4, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1> >(int, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}, std::array, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "count": 26, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 51.51899999982197, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1200 + ], + [] + ], + "cpu_us": 19.272000000000844, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200, + 1 + ], + [ + 2 + ], + [] + ], + "cpu_us": 18.424999999999272, + "gpu_us": 2.848999999998341, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 11, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 14.854000000199449, + "annotation": false + }, + { + "op": "aten::clamp", + "device_type": "DeviceType.CPU", + "count": 4, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [] + ], + "cpu_us": 38.84100000000399, + "gpu_us": 4.418000000005122, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 4, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [], + [], + [] + ], + "cpu_us": 1.3759999999965657, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200, + 1 + ], + [ + 1200, + 1 + ], + [] + ], + "cpu_us": 15.443999999999505, + "gpu_us": 2.0819999999985157, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::CUDAFunctor_add, std::array, false>(int, at::native::CUDAFunctor_add, std::array)", + "device_type": "DeviceType.CUDA", + "count": 3122, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 6029.08300000029, + "annotation": false + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200, + 1 + ], + [ + 2 + ], + [] + ], + "cpu_us": 15.290999999997439, + "gpu_us": 5.283999999999651, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 194, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 566.3139999990817, + "annotation": false + }, + { + "op": "aten::abs", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200, + 2 + ] + ], + "cpu_us": 9.867999999998574, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::abs", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200, + 2 + ], + [ + 0 + ] + ], + "cpu_us": 18.23399999999674, + "gpu_us": 2.0499999999956344, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::AbsFunctor, std::array, false>(int, at::native::AbsFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "count": 2, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 2.0499999999956344, + "annotation": false + }, + { + "op": "aten::rsub", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [] + ], + "cpu_us": 7.166000000001077, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [], + [ + 1200, + 2 + ], + [] + ], + "cpu_us": 18.049000000002707, + "gpu_us": 2.0499999999956344, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::CUDAFunctorOnOther_add, std::array, false>(int, at::native::CUDAFunctorOnOther_add, std::array)", + "device_type": "DeviceType.CUDA", + "count": 2, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 2.0499999999956344, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::launch_clamp_scalar(at::TensorIteratorBase&, c10::Scalar, c10::Scalar, at::native::detail::ClampLimits)::{lambda()#1}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::(anonymous namespace)::launch_clamp_scalar(at::TensorIteratorBase&, c10::Scalar, c10::Scalar, at::native::detail::ClampLimits)::{lambda()#1}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 2, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 2.1120000000009895, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 5, + "input_shapes": [ + [ + 1200, + 2 + ], + [] + ], + "cpu_us": 11.406000000002678, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 9, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [], + [] + ], + "cpu_us": 4.7409999999945285, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [] + ], + "cpu_us": 8.024000000001251, + "gpu_us": 1.087999999999738, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [ + 1200, + 1, + 2 + ], + [] + ], + "cpu_us": 8.421999999998661, + "gpu_us": 1.4089999999996508, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200, + 2, + 2 + ], + [] + ], + "cpu_us": 3.3410000000003492, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200, + 2, + 2 + ], + [] + ], + "cpu_us": 3.4360000000015134, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [ + 1200, + 1, + 2 + ] + ], + "cpu_us": 8.286000000000058, + "gpu_us": 1.3760000000002037, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 4658, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 21302.02800000647, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 9, + "input_shapes": [ + [ + 1 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 15.997000000003027, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 84, + "input_shapes": [ + [ + 1 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 283.7989999995516, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 85, + "input_shapes": [ + [ + 1 + ], + [ + 1 + ], + [] + ], + "cpu_us": 486.95600000065315, + "gpu_us": 72.7409999999727, + "annotation": false + }, + { + "op": "aten::lift_fresh", + "device_type": "DeviceType.CPU", + "count": 9, + "input_shapes": [ + [ + 1 + ] + ], + "cpu_us": 3.37200000017765, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::detach_", + "device_type": "DeviceType.CPU", + "count": 9, + "input_shapes": [ + [ + 1 + ] + ], + "cpu_us": 19.9709999996885, + "gpu_us": 0, + "annotation": false + }, + { + "op": "detach_", + "device_type": "DeviceType.CPU", + "count": 9, + "input_shapes": [ + [ + 1 + ] + ], + "cpu_us": 7.7940000002563465, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::resolve_conj", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1, + 3 + ] + ], + "cpu_us": 0.31999999999970896, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::resolve_neg", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1, + 3 + ] + ], + "cpu_us": 0.1889999999984866, + "gpu_us": 0, + "annotation": false + }, + { + "op": "Memcpy DtoH (Device -> Pageable)", + "device_type": "DeviceType.CUDA", + "count": 91, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 84.36000000022977, + "annotation": false + }, + { + "op": "aten::resolve_conj", + "device_type": "DeviceType.CPU", + "count": 74, + "input_shapes": [ + [ + 1 + ] + ], + "cpu_us": 13.941999999980908, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::resolve_neg", + "device_type": "DeviceType.CPU", + "count": 74, + "input_shapes": [ + [ + 1 + ] + ], + "cpu_us": 10.890000000006694, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 74, + "input_shapes": [ + [ + 1 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 115.23500000000058, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::meshgrid", + "device_type": "DeviceType.CPU", + "count": 9, + "input_shapes": [ + [], + [] + ], + "cpu_us": 97.14299999991272, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 30 + ], + [] + ], + "cpu_us": 1.7340000000003783, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 30, + 1 + ], + [], + [] + ], + "cpu_us": 2.8250000000007276, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 30, + 1 + ], + [], + [], + [] + ], + "cpu_us": 0.9389999999984866, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 40 + ], + [] + ], + "cpu_us": 0.8450000000011642, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1, + 40 + ], + [], + [] + ], + "cpu_us": 1.8840000000018335, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1, + 40 + ], + [], + [], + [] + ], + "cpu_us": 0.5900000000001455, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 30, + 40 + ], + [] + ], + "cpu_us": 7.571000000003551, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 30, + 40 + ], + [], + [] + ], + "cpu_us": 3.9769999999989523, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 15, + 2, + 20, + 2 + ], + [], + [] + ], + "cpu_us": 6.174000000002707, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 15, + 2, + 20, + 2 + ], + [], + [], + [] + ], + "cpu_us": 1.5560000000004948, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::flatten", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 15, + 20, + 2, + 2 + ], + [], + [] + ], + "cpu_us": 7.758999999998196, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 15, + 20, + 2, + 2 + ], + [] + ], + "cpu_us": 7.43999999999869, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 15, + 20, + 2, + 2 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 3.6380000000026484, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 15, + 20, + 2, + 2 + ], + [ + 15, + 20, + 2, + 2 + ], + [] + ], + "cpu_us": 11.945999999999913, + "gpu_us": 2.72099999999773, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 2, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 2.72099999999773, + "annotation": false + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 15, + 20, + 2, + 2 + ], + [] + ], + "cpu_us": 2.291000000001077, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::stack", + "device_type": "DeviceType.CPU", + "count": 9, + "input_shapes": [ + [], + [] + ], + "cpu_us": 77.50400000033187, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::cat", + "device_type": "DeviceType.CPU", + "count": 496, + "input_shapes": [ + [], + [] + ], + "cpu_us": 4746.1369999978015, + "gpu_us": 2189.0840000005264, + "annotation": false + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy_alignedK_contig, unsigned int, 2, 128, 1, 16>(at::native::(anonymous namespace)::OpaqueType<8u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 128, 1>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "count": 9, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 15.942000000071857, + "annotation": false + }, + { + "op": "aten::repeat", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 2 + ], + [] + ], + "cpu_us": 22.107000000007247, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [] + ], + "cpu_us": 3.894000000000233, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::unfold", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [], + [] + ], + "cpu_us": 2.683000000000902, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::unfold", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1, + 2, + 1200 + ], + [], + [], + [] + ], + "cpu_us": 1.7730000000010477, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1, + 2, + 1200 + ], + [], + [], + [] + ], + "cpu_us": 0.5580000000009022, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand_as", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 2 + ], + [ + 1, + 1, + 1200, + 2 + ] + ], + "cpu_us": 1.7409999999981665, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1, + 1, + 1200, + 2 + ], + [ + 1, + 1, + 1200, + 2 + ], + [] + ], + "cpu_us": 3.2520000000004075, + "gpu_us": 0.9290000000000873, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 2 + ], + [], + [] + ], + "cpu_us": 9.833999999998923, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 2 + ], + [] + ], + "cpu_us": 2.92699999999968, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 51, + "input_shapes": [ + [ + 2 + ], + [], + [], + [] + ], + "cpu_us": 30.518999999996595, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 2, + 2 + ], + [], + [], + [] + ], + "cpu_us": 3.114000000001397, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 2, + 2 + ], + [], + [], + [], + [] + ], + "cpu_us": 2.6520000000018626, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 2, + 2 + ], + [], + [], + [] + ], + "cpu_us": 0.6549999999988358, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::flatten", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 2, + 2 + ], + [], + [] + ], + "cpu_us": 3.969999999997526, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 2, + 2 + ], + [] + ], + "cpu_us": 0.647000000000844, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::permute", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1, + 1, + 1200, + 2 + ], + [] + ], + "cpu_us": 2.9069999999992433, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1, + 1, + 1200, + 2 + ], + [], + [], + [] + ], + "cpu_us": 0.477999999999156, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1, + 1200, + 1, + 2 + ], + [] + ], + "cpu_us": 1.1829999999972642, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1, + 1200, + 1, + 2 + ], + [] + ], + "cpu_us": 0.49100000000180444, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [], + [] + ], + "cpu_us": 1.3260000000009313, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 2 + ], + [], + [], + [], + [] + ], + "cpu_us": 1.7910000000010768, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::index_select", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1 + ], + [], + [ + 1 + ] + ], + "cpu_us": 17.45999999999549, + "gpu_us": 1.6330000000016298, + "annotation": false + }, + { + "op": "void at::native::(anonymous namespace)::indexSelectSmallIndex(at::cuda::detail::TensorInfo, at::cuda::detail::TensorInfo, at::cuda::detail::TensorInfo, int, int, unsigned int, long)", + "device_type": "DeviceType.CUDA", + "count": 1, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1.6330000000016298, + "annotation": false + }, + { + "op": "void at::native::unrolled_elementwise_kernel, 4, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1> >(int, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#3}::operator()() const::{lambda(int)#1}, std::array, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "count": 1, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1.217000000000553, + "annotation": false + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceScanInitKernel >(at_cuda_detail::cub::ScanTileState, int)", + "device_type": "DeviceType.CUDA", + "count": 1, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 0.8330000000023574, + "annotation": false + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceScanKernel >::Policy1000, int const*, int*, at_cuda_detail::cub::ScanTileState, std::plus, at_cuda_detail::cub::NullType, unsigned int, int, false, at_cuda_detail::cub::NullType>(int const*, int*, at_cuda_detail::cub::ScanTileState, int, std::plus, at_cuda_detail::cub::NullType, unsigned int)", + "device_type": "DeviceType.CUDA", + "count": 1, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1.441000000002532, + "annotation": false + }, + { + "op": "aten::pad", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1 + ], + [], + [], + [] + ], + "cpu_us": 3.0169999999998254, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::constant_pad_nd", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1 + ], + [], + [] + ], + "cpu_us": 7.142000000003463, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 2 + ], + [] + ], + "cpu_us": 6.881000000001222, + "gpu_us": 0.864000000001397, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::FillFunctor, std::array, false>(int, at::native::FillFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "count": 1, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 0.864000000001397, + "annotation": false + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 2 + ], + [], + [], + [] + ], + "cpu_us": 1.698999999996886, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 49, + "input_shapes": [ + [ + 2 + ], + [], + [], + [], + [] + ], + "cpu_us": 152.88899999996283, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 1536 + ], + [] + ], + "cpu_us": 2.65400000000227, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 3, + 2, + 16, + 16 + ], + [], + [], + [], + [] + ], + "cpu_us": 0.3870000000024447, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::conv3d", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 3, + 2, + 16, + 16 + ], + [ + 1024, + 3, + 2, + 16, + 16 + ], + [ + 1024 + ], + [], + [], + [], + [] + ], + "cpu_us": 4.559000000001106, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::convolution", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 3, + 2, + 16, + 16 + ], + [ + 1024, + 3, + 2, + 16, + 16 + ], + [ + 1024 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 6.623999999999796, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_convolution", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 3, + 2, + 16, + 16 + ], + [ + 1024, + 3, + 2, + 16, + 16 + ], + [ + 1024 + ], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 13.89199999999255, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::cudnn_convolution", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 3, + 2, + 16, + 16 + ], + [ + 1024, + 3, + 2, + 16, + 16 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 112.9409999999989, + "gpu_us": 830.2000000000007, + "annotation": false + }, + { + "op": "cudaMemsetAsync", + "device_type": "DeviceType.CPU", + "count": 1204, + "input_shapes": [], + "cpu_us": 6037.405000001621, + "gpu_us": 0, + "annotation": false + }, + { + "op": "cudaGetErrorString", + "device_type": "DeviceType.CPU", + "count": 4, + "input_shapes": [], + "cpu_us": 0.9869999999973516, + "gpu_us": 0, + "annotation": false + }, + { + "op": "Memset (Device)", + "device_type": "DeviceType.CUDA", + "count": 1204, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 614.463999999356, + "annotation": false + }, + { + "op": "void cudnn::engines_precompiled::nchwToNhwcKernel<__nv_bfloat16, __nv_bfloat16, float, false, true, (cudnnKernelDataType_t)0>(cudnn::engines_precompiled::nchw2nhwc_params_t, __nv_bfloat16 const*, __nv_bfloat16*)", + "device_type": "DeviceType.CUDA", + "count": 2, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 41.943999999999505, + "annotation": false + }, + { + "op": "cudaFuncGetAttributes", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [], + "cpu_us": 9.00800000000163, + "gpu_us": 0, + "annotation": false + }, + { + "op": "cudaLaunchKernelExC", + "device_type": "DeviceType.CPU", + "count": 1459, + "input_shapes": [], + "cpu_us": 7022.051000001109, + "gpu_us": 0, + "annotation": false + }, + { + "op": "sm80_xmma_fprop_implicit_gemm_indexed_bf16bf16_bf16f32_f32_nhwckrsc_nhwc_tilesize128x256x32_stage3_warpsize2x4x1_g1_tensor16x8x16_execute_kernel__5x_cudnn", + "device_type": "DeviceType.CUDA", + "count": 1, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 779.5470000000023, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1024 + ], + [] + ], + "cpu_us": 1.379000000000815, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1024 + ], + [] + ], + "cpu_us": 1.026000000001659, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::add_", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 1024, + 1, + 1, + 1 + ], + [ + 1, + 1024, + 1, + 1, + 1 + ], + [] + ], + "cpu_us": 9.840000000003783, + "gpu_us": 4.065999999998894, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 1024, + 1, + 1, + 1 + ], + [] + ], + "cpu_us": 1.5929999999971187, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::embedding", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 2304, + 1024 + ], + [ + 1200, + 4 + ], + [], + [], + [] + ], + "cpu_us": 7.138999999999214, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 4 + ], + [] + ], + "cpu_us": 1.1199999999989814, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 4 + ], + [] + ], + "cpu_us": 0.6330000000016298, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::index_select", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 2304, + 1024 + ], + [], + [ + 4800 + ] + ], + "cpu_us": 12.352000000009866, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 4800 + ], + [] + ], + "cpu_us": 0.4959999999991851, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 4800, + 1 + ], + [], + [] + ], + "cpu_us": 1.9729999999981374, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 4800, + 1 + ], + [], + [], + [] + ], + "cpu_us": 0.9589999999989232, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::gather", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 2304, + 1024 + ], + [], + [ + 4800, + 1024 + ], + [], + [ + 4800, + 1024 + ] + ], + "cpu_us": 12.484000000000378, + "gpu_us": 6.979999999999563, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 4800, + 1024 + ], + [], + [], + [] + ], + "cpu_us": 0.5129999999990105, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 2304, + 1024 + ], + [], + [], + [] + ], + "cpu_us": 0.5429999999978463, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 4800, + 1024 + ], + [] + ], + "cpu_us": 0.6260000000002037, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 4 + ], + [] + ], + "cpu_us": 3.7669999999961874, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 4 + ], + [], + [], + [] + ], + "cpu_us": 0.4970000000030268, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 4, + 1024 + ], + [ + 1200, + 4, + 1 + ] + ], + "cpu_us": 11.422999999998865, + "gpu_us": 15.625, + "annotation": false + }, + { + "op": "aten::sum", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 4, + 1024 + ], + [], + [], + [] + ], + "cpu_us": 16.834999999999127, + "gpu_us": 11.81499999999869, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [], + [] + ], + "cpu_us": 0.5030000000006112, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 49, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [], + [], + [] + ], + "cpu_us": 79.13400000004185, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 49, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 199.89199999992707, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 49, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 1200, + 1024 + ], + [] + ], + "cpu_us": 246.52599999999438, + "gpu_us": 163.60699999998178, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 73, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 1200, + 1024 + ], + [] + ], + "cpu_us": 582.6000000000095, + "gpu_us": 361.9990000000216, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [], + [], + [], + [] + ], + "cpu_us": 1.3700000000026193, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 3.745999999999185, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [ + 1200, + 2, + 1 + ], + [] + ], + "cpu_us": 4.8289999999979045, + "gpu_us": 2.0169999999998254, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 16 + ], + [], + [], + [], + [] + ], + "cpu_us": 0.4290000000000873, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 2, + 1 + ], + [ + 16 + ] + ], + "cpu_us": 9.621999999999389, + "gpu_us": 1.5360000000000582, + "annotation": false + }, + { + "op": "aten::cos", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 2, + 16 + ] + ], + "cpu_us": 12.366000000001804, + "gpu_us": 1.8250000000007276, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200, + 2, + 16 + ], + [] + ], + "cpu_us": 16.39400000000387, + "gpu_us": 2.08100000000195, + "annotation": false + }, + { + "op": "aten::sin", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 2, + 16 + ] + ], + "cpu_us": 10.117000000002008, + "gpu_us": 1.6970000000001164, + "annotation": false + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "count": 4, + "input_shapes": [ + [ + 1200, + 2, + 16 + ], + [], + [] + ], + "cpu_us": 11.138000000006286, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 4, + "input_shapes": [ + [ + 1200, + 2, + 16 + ], + [], + [], + [] + ], + "cpu_us": 2.1089999999967404, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1200, + 1024 + ], + [] + ], + "cpu_us": 1.4650000000001455, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 1200, + 1024 + ], + [] + ], + "cpu_us": 3.297000000002299, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::layer_norm", + "device_type": "DeviceType.CPU", + "count": 49, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [ + 1024 + ], + [ + 1024 + ], + [], + [] + ], + "cpu_us": 182.32599999999366, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::native_layer_norm", + "device_type": "DeviceType.CPU", + "count": 49, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [ + 1024 + ], + [ + 1024 + ], + [] + ], + "cpu_us": 634.5269999999218, + "gpu_us": 217.7239999999947, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 3072, + 1024 + ], + [ + 3072 + ] + ], + "cpu_us": 80.5770000000266, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 3072, + 1024 + ] + ], + "cpu_us": 41.27099999997881, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 3072, + 1024 + ], + [], + [] + ], + "cpu_us": 40.4320000000298, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 3072, + 1024 + ], + [], + [], + [] + ], + "cpu_us": 11.774999999983265, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 3072 + ], + [ + 1200, + 1024 + ], + [ + 1024, + 3072 + ], + [], + [] + ], + "cpu_us": 400.5579999999791, + "gpu_us": 1345.4680000000044, + "annotation": false + }, + { + "op": "cudaOccupancyMaxActiveBlocksPerMultiprocessor", + "device_type": "DeviceType.CPU", + "count": 1682, + "input_shapes": [], + "cpu_us": 1976.612000000503, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 3072 + ], + [] + ], + "cpu_us": 40.19700000001103, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 3072 + ], + [] + ], + "cpu_us": 43.57199999999648, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::permute", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 3, + 16, + 64 + ], + [] + ], + "cpu_us": 95.81099999999788, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 3, + 16, + 64 + ], + [], + [], + [] + ], + "cpu_us": 18.055999999996857, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::unbind", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 3, + 1200, + 16, + 64 + ], + [] + ], + "cpu_us": 136.11100000000806, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "count": 72, + "input_shapes": [ + [ + 3, + 1200, + 16, + 64 + ], + [], + [] + ], + "cpu_us": 159.03599999999642, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 72, + "input_shapes": [ + [ + 3, + 1200, + 16, + 64 + ], + [], + [], + [] + ], + "cpu_us": 42.97499999999127, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 96, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [], + [], + [], + [] + ], + "cpu_us": 134.145000000055, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 96, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 353.7079999999514, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 96, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [ + 1200, + 16, + 64 + ], + [] + ], + "cpu_us": 451.8360000000248, + "gpu_us": 436.57099999995626, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 48, + "input_shapes": [ + [ + 1200, + 64 + ], + [] + ], + "cpu_us": 155.23799999997573, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 48, + "input_shapes": [ + [ + 1200, + 64 + ], + [], + [], + [] + ], + "cpu_us": 25.181999999993423, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 48, + "input_shapes": [ + [ + 1200, + 1, + 64 + ], + [], + [], + [], + [] + ], + "cpu_us": 15.876999999974942, + "gpu_us": 0, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 129, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 271.10400000005757, + "annotation": false + }, + { + "op": "void at::native::vectorized_gather_kernel<16, long>(char*, char*, long*, int, long, long, long, long, bool)", + "device_type": "DeviceType.CUDA", + "count": 9, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 26.957000000216794, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 96, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [ + 1200, + 1, + 64 + ] + ], + "cpu_us": 740.9379999999801, + "gpu_us": 448.95500000000175, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 1, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 15.625, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 96, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [], + [], + [], + [] + ], + "cpu_us": 278.41399999999703, + "gpu_us": 0, + "annotation": false + }, + { + "op": "void at::native::reduce_kernel<128, 4, at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(float, float)#1}>, unsigned int, float, 4, 4> >(at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(float, float)#1}>, unsigned int, float, 4, 4>)", + "device_type": "DeviceType.CUDA", + "count": 1, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 11.81499999999869, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 168, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [], + [], + [] + ], + "cpu_us": 101.92500000003565, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::neg", + "device_type": "DeviceType.CPU", + "count": 48, + "input_shapes": [ + [ + 1200, + 16, + 32 + ] + ], + "cpu_us": 372.5080000000489, + "gpu_us": 129.25799999999435, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::CUDAFunctor_add, std::array, false>(int, at::native::CUDAFunctor_add, std::array)", + "device_type": "DeviceType.CUDA", + "count": 561, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 2837.666000001009, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::cos_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::cos_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 9, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 16.23099999966871, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::sin_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::sin_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 9, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 16.072999999974854, + "annotation": false + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy, unsigned int, 2, 64, 64>(at::native::(anonymous namespace)::OpaqueType<4u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 64, 64>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "count": 2, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 3.875, + "annotation": false + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy_vectorized, unsigned int, 2, 128, 1, 16, 4>(char*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 128, 1>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "count": 2, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 3.1379999999990105, + "annotation": false + }, + { + "op": "void at::native::(anonymous namespace)::vectorized_layer_norm_kernel(int, float, c10::BFloat16 const*, c10::BFloat16 const*, c10::BFloat16 const*, float*, float*, c10::BFloat16*)", + "device_type": "DeviceType.CUDA", + "count": 49, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 217.7239999999947, + "annotation": false + }, + { + "op": "ampere_bf16_s1688gemm_bf16_128x128_ldg8_relu_f2f_stages_32x1_tn", + "device_type": "DeviceType.CUDA", + "count": 24, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1345.4680000000044, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 48, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [ + 1200, + 16, + 64 + ], + [] + ], + "cpu_us": 338.0779999999904, + "gpu_us": 216.0880000000434, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 880, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 5629.364000000074, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 48, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 129.25799999999435, + "annotation": false + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy, unsigned int, 3, 64, 64>(at::native::(anonymous namespace)::OpaqueType<4u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 64, 64>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "count": 64, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 265.2730000001138, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 72, + "input_shapes": [ + [ + 1200, + 16, + 64 + ], + [], + [] + ], + "cpu_us": 239.2709999999861, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 72, + "input_shapes": [ + [ + 16, + 1200, + 64 + ], + [] + ], + "cpu_us": 173.75699999997596, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 72, + "input_shapes": [ + [ + 16, + 1200, + 64 + ], + [], + [], + [] + ], + "cpu_us": 46.30100000000675, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1 + ], + [ + 1 + ], + [] + ], + "cpu_us": 307.5789999999979, + "gpu_us": 25.645000000000437, + "annotation": false + }, + { + "op": "void at::native::unrolled_elementwise_kernel, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast>(int, at::native::CUDAFunctor_add, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast)", + "device_type": "DeviceType.CUDA", + "count": 24, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 25.645000000000437, + "annotation": false + }, + { + "op": "aten::split_with_sizes", + "device_type": "DeviceType.CPU", + "count": 72, + "input_shapes": [ + [ + 1, + 16, + 1200, + 64 + ], + [], + [] + ], + "cpu_us": 213.09499999993932, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 168, + "input_shapes": [ + [ + 1, + 16, + 1200, + 64 + ], + [], + [], + [] + ], + "cpu_us": 136.974000000042, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::scaled_dot_product_attention", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 16, + 1200, + 64 + ], + [ + 1, + 16, + 1200, + 64 + ], + [ + 1, + 16, + 1200, + 64 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 324.4859999999826, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_scaled_dot_product_flash_attention", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 16, + 1200, + 64 + ], + [ + 1, + 16, + 1200, + 64 + ], + [ + 1, + 16, + 1200, + 64 + ], + [], + [], + [], + [] + ], + "cpu_us": 277.46099999993385, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 96, + "input_shapes": [ + [ + 1, + 16, + 1200, + 64 + ], + [], + [] + ], + "cpu_us": 243.916000000012, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::_flash_attention_forward", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [ + 1, + 1200, + 16, + 64 + ], + [ + 1, + 1200, + 16, + 64 + ], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 423.1320000000087, + "gpu_us": 1791.4139999999861, + "annotation": false + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 65.67799999997806, + "gpu_us": 0, + "annotation": false + }, + { + "op": "cudaFuncSetAttribute", + "device_type": "DeviceType.CPU", + "count": 88, + "input_shapes": [], + "cpu_us": 332.0830000007445, + "gpu_us": 0, + "annotation": false + }, + { + "op": "void pytorch_flash::flash_fwd_kernel >, false, false, false, false, false, true, false, false>(pytorch_flash::Flash_fwd_params)", + "device_type": "DeviceType.CUDA", + "count": 24, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1791.4139999999861, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [], + [] + ], + "cpu_us": 47.51699999999255, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 48, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [], + [], + [] + ], + "cpu_us": 26.989000000001397, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [], + [], + [] + ], + "cpu_us": 58.20599999999831, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [], + [], + [], + [] + ], + "cpu_us": 45.85800000000381, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [] + ], + "cpu_us": 46.223000000001775, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 1200, + 16, + 64 + ], + [] + ], + "cpu_us": 60.70300000000134, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 1024, + 1024 + ], + [ + 1024 + ] + ], + "cpu_us": 113.37199999997756, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1024, + 1024 + ] + ], + "cpu_us": 54.33500000001004, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1024, + 1024 + ], + [], + [] + ], + "cpu_us": 42.334999999966385, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1024, + 1024 + ], + [], + [], + [] + ], + "cpu_us": 10.13900000002468, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1024 + ], + [ + 1200, + 1024 + ], + [ + 1024, + 1024 + ], + [], + [] + ], + "cpu_us": 681.8360000000175, + "gpu_us": 562.3960000000006, + "annotation": false + }, + { + "op": "cuLaunchKernel", + "device_type": "DeviceType.CPU", + "count": 473, + "input_shapes": [], + "cpu_us": 2137.2000000010594, + "gpu_us": 0, + "annotation": false + }, + { + "op": "void cutlass::Kernel2(cutlass_80_tensorop_bf16_s16816gemm_relu_bf16_64x64_32x6_tn_align8::Params)", + "device_type": "DeviceType.CUDA", + "count": 24, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 551.1909999999953, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 4096, + 1024 + ], + [ + 4096 + ] + ], + "cpu_us": 70.44500000000335, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 4096, + 1024 + ] + ], + "cpu_us": 44.856999999992695, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 4096, + 1024 + ], + [], + [] + ], + "cpu_us": 42.47699999998804, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 4096, + 1024 + ], + [], + [], + [] + ], + "cpu_us": 10.556000000022323, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 4096 + ], + [ + 1200, + 1024 + ], + [ + 1024, + 4096 + ], + [], + [] + ], + "cpu_us": 426.8890000000465, + "gpu_us": 1834.9940000000024, + "annotation": false + }, + { + "op": "ampere_bf16_s1688gemm_bf16_128x64_sliced1x2_ldg8_relu_f2f_tn", + "device_type": "DeviceType.CUDA", + "count": 50, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 3846.8570000000036, + "annotation": false + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 1024 + ], + [], + [] + ], + "cpu_us": 8.449999999982538, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 16, + 1024 + ], + [] + ], + "cpu_us": 58.98299999997471, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 16, + 1024 + ] + ], + "cpu_us": 40.78900000000431, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 16, + 1024 + ], + [], + [] + ], + "cpu_us": 44.01199999999153, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 16, + 1024 + ], + [], + [], + [] + ], + "cpu_us": 14.267000000025291, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 1024, + 16 + ] + ], + "cpu_us": 43.947999999974854, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 1024 + ], + [ + 1024, + 16 + ] + ], + "cpu_us": 497.0919999999969, + "gpu_us": 195.44400000000678, + "annotation": false + }, + { + "op": "ampere_sgemm_32x32_sliced1x4_tn", + "device_type": "DeviceType.CUDA", + "count": 1074, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 8632.563999998936, + "annotation": false + }, + { + "op": "void cublasLt::splitKreduce_kernel<32, 16, int, float, float, float, float, false, float, float, float, true, false, false, false>(cublasLt::cublasSplitKParams, float const*, float const*, float*, float*, float const*, float const*, float const*, float const*, float*, void*, long, float*, int*, float*, float*, float const*, float const*, float const*, float const*, float const*)", + "device_type": "DeviceType.CUDA", + "count": 1074, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1550.4030000008606, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 4096, + 16 + ], + [] + ], + "cpu_us": 52.034000000065134, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 25, + "input_shapes": [ + [ + 4096, + 16 + ] + ], + "cpu_us": 41.29299999999421, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 25, + "input_shapes": [ + [ + 4096, + 16 + ], + [], + [] + ], + "cpu_us": 43.465000000018335, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 25, + "input_shapes": [ + [ + 4096, + 16 + ], + [], + [], + [] + ], + "cpu_us": 10.84999999998763, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 16, + 4096 + ] + ], + "cpu_us": 29.865999999947235, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 16, + 4096 + ] + ], + "cpu_us": 281.990000000038, + "gpu_us": 302.66599999999016, + "annotation": false + }, + { + "op": "ampere_sgemm_128x32_tn", + "device_type": "DeviceType.CUDA", + "count": 882, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 8036.223000000777, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 4096 + ], + [] + ], + "cpu_us": 261.11299999996845, + "gpu_us": 321.07700000002296, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 1200, + 4096 + ], + [] + ], + "cpu_us": 188.7009999999973, + "gpu_us": 677.9199999999655, + "annotation": false + }, + { + "op": "void at::native::unrolled_elementwise_kernel, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1> >(int, at::native::CUDAFunctor_add, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "count": 1074, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 13843.578999998921, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 48, + "input_shapes": [ + [ + 1200, + 4096 + ], + [], + [], + [], + [] + ], + "cpu_us": 80.55899999996473, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 48, + "input_shapes": [ + [ + 1200, + 4096 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 175.12800000005154, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 48, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 1200, + 4096 + ], + [] + ], + "cpu_us": 222.60999999998603, + "gpu_us": 456.4530000000159, + "annotation": false + }, + { + "op": "aten::gelu", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 4096 + ], + [] + ], + "cpu_us": 227.82100000001083, + "gpu_us": 154.55100000001403, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::GeluCUDAKernelImpl(at::TensorIteratorBase&, at::native::GeluType)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array, false>(int, at::native::GeluCUDAKernelImpl(at::TensorIteratorBase&, at::native::GeluType)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 24, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 154.55100000001403, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 1024, + 4096 + ], + [ + 1024 + ] + ], + "cpu_us": 62.81999999998152, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1024, + 4096 + ] + ], + "cpu_us": 44.90700000000652, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1024, + 4096 + ], + [], + [] + ], + "cpu_us": 44.16600000000108, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1024, + 4096 + ], + [], + [], + [] + ], + "cpu_us": 12.317999999999302, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1024 + ], + [ + 1200, + 4096 + ], + [ + 4096, + 1024 + ], + [], + [] + ], + "cpu_us": 436.824000000026, + "gpu_us": 1873.734000000004, + "annotation": false + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 4096 + ], + [], + [] + ], + "cpu_us": 5.350000000005821, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 16, + 4096 + ], + [] + ], + "cpu_us": 54.29600000001665, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 90, + "input_shapes": [ + [ + 16, + 4096 + ] + ], + "cpu_us": 154.73199999947246, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 90, + "input_shapes": [ + [ + 16, + 4096 + ], + [], + [] + ], + "cpu_us": 152.0189999987124, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 90, + "input_shapes": [ + [ + 16, + 4096 + ], + [], + [], + [] + ], + "cpu_us": 47.78600000127335, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 4096, + 16 + ] + ], + "cpu_us": 35.0809999999874, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 4096 + ], + [ + 4096, + 16 + ] + ], + "cpu_us": 372.466999999986, + "gpu_us": 403.65199999998003, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 1024, + 16 + ], + [] + ], + "cpu_us": 49.059000000004744, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 152, + "input_shapes": [ + [ + 1024, + 16 + ] + ], + "cpu_us": 243.87400000148773, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 152, + "input_shapes": [ + [ + 1024, + 16 + ], + [], + [] + ], + "cpu_us": 385.36199999976816, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 152, + "input_shapes": [ + [ + 1024, + 16 + ], + [], + [], + [] + ], + "cpu_us": 72.25299999934941, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 16, + 1024 + ] + ], + "cpu_us": 28.52999999999156, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 16 + ], + [ + 16, + 1024 + ] + ], + "cpu_us": 260.06299999998737, + "gpu_us": 109.2809999999954, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1200, + 1024 + ], + [] + ], + "cpu_us": 199.55600000001505, + "gpu_us": 86.03100000001723, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 4096, + 4096 + ], + [ + 4096 + ] + ], + "cpu_us": 2.346000000012282, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 4096, + 4096 + ] + ], + "cpu_us": 1.8439999999973224, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 4096, + 4096 + ], + [], + [] + ], + "cpu_us": 1.5049999999973807, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 4096, + 4096 + ], + [], + [], + [] + ], + "cpu_us": 0.4360000000015134, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 4096 + ], + [ + 300, + 4096 + ], + [ + 4096, + 4096 + ], + [], + [] + ], + "cpu_us": 15.634000000005472, + "gpu_us": 84.40000000000873, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 3, + "input_shapes": [ + [ + 300, + 4096 + ], + [], + [], + [], + [] + ], + "cpu_us": 3.973999999994703, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 3, + "input_shapes": [ + [ + 300, + 4096 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 10.004000000022643, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 3, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 300, + 4096 + ], + [] + ], + "cpu_us": 13.202000000012049, + "gpu_us": 10.66299999999319, + "annotation": false + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 300, + 4096 + ], + [], + [] + ], + "cpu_us": 0.4170000000085565, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 16, + 4096 + ], + [] + ], + "cpu_us": 3.802000000010594, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 4096, + 16 + ] + ], + "cpu_us": 2.5599999999903957, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 4096, + 16 + ] + ], + "cpu_us": 26.465000000003783, + "gpu_us": 19.210000000006403, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 4096, + 16 + ], + [] + ], + "cpu_us": 1.8139999999984866, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 16, + 4096 + ] + ], + "cpu_us": 1.1149999999979627, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 16, + 4096 + ] + ], + "cpu_us": 10.610000000000582, + "gpu_us": 4.866000000001804, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 4096 + ], + [] + ], + "cpu_us": 7.6269999999931315, + "gpu_us": 3.650000000001455, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 300, + 4096 + ], + [] + ], + "cpu_us": 6.524000000004889, + "gpu_us": 6.051000000006752, + "annotation": false + }, + { + "op": "aten::gelu", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 4096 + ], + [] + ], + "cpu_us": 9.211000000002969, + "gpu_us": 2.4329999999972642, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::GeluCUDAKernelImpl(at::TensorIteratorBase&, at::native::GeluType)::{lambda()#2}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array, false>(int, at::native::GeluCUDAKernelImpl(at::TensorIteratorBase&, at::native::GeluType)::{lambda()#2}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 1, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 2.4329999999972642, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 4096 + ], + [ + 2560, + 4096 + ], + [ + 2560 + ] + ], + "cpu_us": 3.485000000000582, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 257, + "input_shapes": [ + [ + 2560, + 4096 + ] + ], + "cpu_us": 876.7199999992008, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 257, + "input_shapes": [ + [ + 2560, + 4096 + ], + [], + [] + ], + "cpu_us": 587.8239999999932, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 257, + "input_shapes": [ + [ + 2560, + 4096 + ], + [], + [], + [] + ], + "cpu_us": 218.6410000002943, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::addmm", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 2560 + ], + [ + 300, + 4096 + ], + [ + 4096, + 2560 + ], + [], + [] + ], + "cpu_us": 15.576999999997497, + "gpu_us": 64.0679999999993, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 2560, + 16 + ], + [] + ], + "cpu_us": 1.7989999999990687, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 321, + "input_shapes": [ + [ + 2560, + 16 + ] + ], + "cpu_us": 525.926999998992, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 321, + "input_shapes": [ + [ + 2560, + 16 + ], + [], + [] + ], + "cpu_us": 512.9419999999154, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 321, + "input_shapes": [ + [ + 2560, + 16 + ], + [], + [], + [] + ], + "cpu_us": 170.15000000057626, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 16, + 2560 + ] + ], + "cpu_us": 1.1299999999973807, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 16 + ], + [ + 16, + 2560 + ] + ], + "cpu_us": 10.526000000005297, + "gpu_us": 3.5540000000037253, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 2560 + ], + [] + ], + "cpu_us": 7.382999999994354, + "gpu_us": 2.3369999999995343, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 2560 + ], + [ + 300, + 2560 + ], + [] + ], + "cpu_us": 6.472999999998137, + "gpu_us": 3.6820000000006985, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [], + [] + ], + "cpu_us": 1.25, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 3.279999999998836, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 2560 + ], + [ + 300, + 2560 + ], + [] + ], + "cpu_us": 4.097000000001572, + "gpu_us": 1.8570000000036089, + "annotation": false + }, + { + "op": "aten::prod", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1, + 3 + ], + [], + [], + [] + ], + "cpu_us": 22.5570000000007, + "gpu_us": 2.177000000003318, + "annotation": false + }, + { + "op": "reduction_prod_kernel", + "device_type": "DeviceType.CUDA", + "count": 1, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 2.177000000003318, + "annotation": false + }, + { + "op": "aten::floor_divide", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 1 + ], + [] + ], + "cpu_us": 12.0370000000039, + "gpu_us": 1.4729999999981374, + "annotation": false + }, + { + "op": "aten::split_with_sizes", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [] + ], + "cpu_us": 4.230000000003201, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [] + ], + "cpu_us": 1.3839999999981956, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [] + ], + "cpu_us": 3.1849999999976717, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 1, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [], + [] + ], + "cpu_us": 2.1679999999978463, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 38.37500000016735, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 56, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 375.46100000075967, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 56, + "input_shapes": [ + [ + 1, + 456 + ], + [ + 1, + 456 + ], + [] + ], + "cpu_us": 341.1979999990872, + "gpu_us": 73.44999999900028, + "annotation": false + }, + { + "op": "aten::embedding", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 248320, + 2560 + ], + [ + 1, + 456 + ], + [], + [], + [] + ], + "cpu_us": 74.63499999982014, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "cpu_us": 12.77299999974639, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "cpu_us": 10.447000000043772, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::index_select", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 248320, + 2560 + ], + [], + [ + 456 + ] + ], + "cpu_us": 135.16200000095705, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 32, + "input_shapes": [ + [ + 456 + ], + [] + ], + "cpu_us": 28.04500000004191, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 456, + 1 + ], + [], + [] + ], + "cpu_us": 23.16399999960413, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 32, + "input_shapes": [ + [ + 456, + 1 + ], + [], + [], + [] + ], + "cpu_us": 31.093999999953667, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::gather", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 248320, + 2560 + ], + [], + [ + 456, + 2560 + ], + [], + [ + 456, + 2560 + ] + ], + "cpu_us": 141.786000000684, + "gpu_us": 19.97700000021723, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 456, + 2560 + ], + [], + [], + [] + ], + "cpu_us": 3.5499999998210114, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 248320, + 2560 + ], + [], + [], + [] + ], + "cpu_us": 8.85999999971682, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 456, + 2560 + ], + [] + ], + "cpu_us": 4.559999999961292, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 300, + 2560 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 4.99300000002404, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::eq", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "cpu_us": 270.51500000010856, + "gpu_us": 26.830000000023574, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::AUnaryFunctor >, std::array, false>(int, at::native::AUnaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "count": 40, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 43.70399999983056, + "annotation": false + }, + { + "op": "aten::sum", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "cpu_us": 501.2430000001623, + "gpu_us": 47.64700000031007, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [], + [], + [] + ], + "cpu_us": 37.25399999999354, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 1, + 456 + ], + [] + ], + "cpu_us": 68.45799999999872, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 1, + 456, + 1 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 6.321999999912805, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [], + [] + ], + "cpu_us": 91.83899999997084, + "gpu_us": 8.998000000079628, + "annotation": false + }, + { + "op": "aten::eq", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [], + [] + ], + "cpu_us": 194.16699999985576, + "gpu_us": 16.873999999806983, + "annotation": false + }, + { + "op": "aten::detach", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [] + ], + "cpu_us": 17.156000000119093, + "gpu_us": 0, + "annotation": false + }, + { + "op": "detach", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [] + ], + "cpu_us": 25.14899999989575, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::_is_all_true", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [] + ], + "cpu_us": 24.9799999997922, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::all", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [] + ], + "cpu_us": 80.79600000022037, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::view_as", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [], + [] + ], + "cpu_us": 16.863000000375905, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [], + [] + ], + "cpu_us": 6.8839999998308485, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::masked_scatter", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 1 + ], + [ + 300, + 2560 + ] + ], + "cpu_us": 81.54699999993318, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [] + ], + "cpu_us": 17.42200000009325, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [] + ], + "cpu_us": 4.163999999931548, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 456, + 1 + ], + [], + [] + ], + "cpu_us": 13.802000000279804, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 456, + 1 + ], + [], + [], + [] + ], + "cpu_us": 4.631000000015774, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "cpu_us": 48.45199999986653, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 30.03699999928358, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 2080, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 2560 + ], + [] + ], + "cpu_us": 9305.859000003053, + "gpu_us": 7021.58600000415, + "annotation": false + }, + { + "op": "aten::masked_scatter_", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 2560 + ], + [ + 300, + 2560 + ] + ], + "cpu_us": 306.2780000007697, + "gpu_us": 114.78399999917747, + "annotation": false + }, + { + "op": "aten::contiguous", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "cpu_us": 10.43000000010943, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#11}::operator()() const::{lambda(bool)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#11}::operator()() const::{lambda(bool)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 8, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 22.350000000100408, + "annotation": false + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceScanKernel >::Policy1000, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, long*, at_cuda_detail::cub::ScanTileState, at::cuda::cub::(anonymous namespace)::SumOp, at_cuda_detail::cub::detail::InputValue, unsigned int, long, false, long>(thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, long*, at_cuda_detail::cub::ScanTileState, int, at::cuda::cub::(anonymous namespace)::SumOp, at_cuda_detail::cub::detail::InputValue, unsigned int)", + "device_type": "DeviceType.CUDA", + "count": 8, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 60.57899999986694, + "annotation": false + }, + { + "op": "at::native::(anonymous namespace)::masked_scatter_size_check(long const*, bool const*, long)", + "device_type": "DeviceType.CUDA", + "count": 8, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 7.588999999730731, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::launch_masked_scatter_kernel(at::TensorBase const&, at::TensorBase const&, at::TensorBase const&, at::TensorBase const&)::{lambda()#1}::operator()() const::{lambda()#11}::operator()() const::{lambda(c10::BFloat16, bool, long)#1}, std::array, false>(int, at::native::launch_masked_scatter_kernel(at::TensorBase const&, at::TensorBase const&, at::TensorBase const&, at::TensorBase const&)::{lambda()#1}::operator()() const::{lambda()#11}::operator()() const::{lambda(c10::BFloat16, bool, long)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 8, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 39.955999999649066, + "annotation": false + }, + { + "op": "aten::zeros", + "device_type": "DeviceType.CPU", + "count": 392, + "input_shapes": [ + [], + [], + [], + [], + [] + ], + "cpu_us": 1818.1529999997729, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::zero_", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 456 + ] + ], + "cpu_us": 35.20500000010361, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 456 + ], + [] + ], + "cpu_us": 69.05199999971956, + "gpu_us": 7.36400000017602, + "annotation": false + }, + { + "op": "aten::unbind", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 3 + ], + [] + ], + "cpu_us": 67.84700000011799, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 456 + ], + [], + [], + [], + [] + ], + "cpu_us": 45.505000000419386, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 32, + "input_shapes": [ + [ + 456 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 160.57500000036816, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 32, + "input_shapes": [ + [ + 456 + ], + [ + 456 + ], + [] + ], + "cpu_us": 225.98299999948358, + "gpu_us": 53.30699999976059, + "annotation": false + }, + { + "op": "void at::native::unrolled_elementwise_kernel, 4, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1> >(int, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#11}::operator()() const::{lambda(bool)#1}, std::array, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "count": 32, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 60.06599999903119, + "annotation": false + }, + { + "op": "aten::index", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 456 + ], + [] + ], + "cpu_us": 417.93599999986327, + "gpu_us": 48.21799999941868, + "annotation": false + }, + { + "op": "aten::nonzero", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 456 + ] + ], + "cpu_us": 1147.9909999992815, + "gpu_us": 106.52999999878375, + "annotation": false + }, + { + "op": "void at_cuda_detail::cub::detail::reduce::DeviceReduceSingleTileKernel >::Policy1000, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, int*, unsigned long long, cuda::std::__4::plus, int, int, cuda::std::__4::__identity>(thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, int*, unsigned long long, cuda::std::__4::plus, int, cuda::std::__4::__identity)", + "device_type": "DeviceType.CUDA", + "count": 24, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 30.418999999652442, + "annotation": false + }, + { + "op": "void at_cuda_detail::cub::detail::scan::DeviceCompactInitKernel, int*>(at_cuda_detail::cub::ScanTileState, int, int*)", + "device_type": "DeviceType.CUDA", + "count": 24, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 19.466999999407562, + "annotation": false + }, + { + "op": "void at_cuda_detail::cub::detail::select::DeviceSelectSweepKernel::Policy1000, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::counting_iterator, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, long*, int*, at_cuda_detail::cub::ScanTileState, at_cuda_detail::cub::NullType, at_cuda_detail::cub::NullType, int, at_cuda_detail::cub::detail::select::streaming_context_t, (at_cuda_detail::cub::SelectImpl)0>(thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::counting_iterator, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, long*, int*, at_cuda_detail::cub::ScanTileState, at_cuda_detail::cub::NullType, at_cuda_detail::cub::NullType, int, int, at_cuda_detail::cub::detail::select::streaming_context_t, at_cuda_detail::cub::detail::vsmem_t)", + "device_type": "DeviceType.CUDA", + "count": 24, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 35.38200000004872, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "cpu_us": 62.6820000000298, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 456 + ], + [], + [] + ], + "cpu_us": 69.14899999984482, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::set_", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 1, + 456 + ], + [ + 456, + 1 + ] + ], + "cpu_us": 118.55799999982264, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 456, + 1 + ], + [], + [] + ], + "cpu_us": 67.22300000084215, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 456 + ], + [], + [], + [] + ], + "cpu_us": 15.568000000261236, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 456 + ], + [] + ], + "cpu_us": 58.54299999996147, + "gpu_us": 0, + "annotation": false + }, + { + "op": "void at::native::index_elementwise_kernel<128, 4, at::native::gpu_index_kernel >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_kernel_impl >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1}>(long, at::native::gpu_index_kernel >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_kernel_impl >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 16, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 48.21799999941868, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 456 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 12.966000000167696, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 79 + ], + [] + ], + "cpu_us": 26.68000000021857, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 79 + ], + [], + [] + ], + "cpu_us": 52.83499999999185, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 79 + ], + [], + [], + [] + ], + "cpu_us": 8.569999999912397, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 79 + ], + [], + [] + ], + "cpu_us": 142.47499999989668, + "gpu_us": 11.205999999845517, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctorOnSelf_add const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctorOnSelf_add const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 8, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 11.205999999845517, + "annotation": false + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "count": 40, + "input_shapes": [ + [ + 3 + ], + [], + [] + ], + "cpu_us": 156.02500000035798, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 40, + "input_shapes": [ + [ + 3 + ], + [], + [], + [] + ], + "cpu_us": 27.3259999997681, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1 + ], + [] + ], + "cpu_us": 88.66899999992165, + "gpu_us": 8.100999999747728, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 15 + ], + [], + [] + ], + "cpu_us": 74.22599999977683, + "gpu_us": 8.132999999921594, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 20 + ], + [], + [] + ], + "cpu_us": 68.93100000000413, + "gpu_us": 7.909000000006927, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 1, + 1 + ], + [], + [] + ], + "cpu_us": 24.87099999961356, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 1, + 1 + ], + [], + [], + [] + ], + "cpu_us": 6.170000000012806, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 15 + ], + [] + ], + "cpu_us": 9.011999999995169, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 15, + 1 + ], + [], + [] + ], + "cpu_us": 19.385000000096625, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 15, + 1 + ], + [], + [], + [] + ], + "cpu_us": 4.54300000006333, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 20 + ], + [] + ], + "cpu_us": 6.782999999872118, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 1, + 20 + ], + [], + [] + ], + "cpu_us": 20.07900000012887, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 1, + 20 + ], + [], + [], + [] + ], + "cpu_us": 7.083999999988009, + "gpu_us": 0, + "annotation": false + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy, unsigned int, 3, 64, 64>(at::native::(anonymous namespace)::OpaqueType<8u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 64, 64>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "count": 8, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 15.911000000029162, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 15, + 20 + ], + [] + ], + "cpu_us": 9.404999999678694, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 15, + 20 + ], + [] + ], + "cpu_us": 37.7920000005106, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 15, + 20 + ], + [] + ], + "cpu_us": 15.542999999961467, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 3, + 300 + ], + [], + [] + ], + "cpu_us": 87.73300000042218, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 3, + 300 + ], + [], + [], + [] + ], + "cpu_us": 10.822000000021944, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::add_", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 300 + ], + [], + [] + ], + "cpu_us": 79.99400000001333, + "gpu_us": 8.517000000050757, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 300 + ], + [ + 300 + ], + [] + ], + "cpu_us": 9.03499999998894, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::gt", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [], + [] + ], + "cpu_us": 118.08600000006845, + "gpu_us": 9.219999999855645, + "annotation": false + }, + { + "op": "void at::native::unrolled_elementwise_kernel, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast>(int, at::native::(anonymous namespace)::CompareFunctor, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithoutCast, at::native::memory::StoreWithoutCast)", + "device_type": "DeviceType.CUDA", + "count": 8, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 9.219999999855645, + "annotation": false + }, + { + "op": "aten::is_nonzero", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [] + ], + "cpu_us": 47.10199999970064, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [], + [], + [] + ], + "cpu_us": 165.69099999940954, + "gpu_us": 15.881999999874097, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 77 + ], + [] + ], + "cpu_us": 14.735999999749765, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 77 + ], + [], + [] + ], + "cpu_us": 37.26999999980035, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 77 + ], + [], + [], + [] + ], + "cpu_us": 9.054000000003725, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 77 + ], + [], + [] + ], + "cpu_us": 145.8860000000641, + "gpu_us": 10.596000000201457, + "annotation": false + }, + { + "op": "aten::add_", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [], + [], + [] + ], + "cpu_us": 80.96399999975984, + "gpu_us": 8.004999999961, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 456 + ], + [] + ], + "cpu_us": 25.168000000019674, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 456 + ], + [] + ], + "cpu_us": 13.493999999933294, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 456 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 4.41699999973207, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 456 + ], + [], + [] + ], + "cpu_us": 33.61499999982334, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 3, + 1, + 456 + ], + [], + [], + [] + ], + "cpu_us": 8.410999999556225, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::index_put_", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 456 + ], + [], + [ + 3, + 456 + ], + [] + ], + "cpu_us": 47.45400000017253, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_index_put_impl_", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 456 + ], + [], + [ + 3, + 456 + ], + [], + [] + ], + "cpu_us": 206.87499999971624, + "gpu_us": 26.70399999982328, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 456 + ], + [], + [], + [] + ], + "cpu_us": 6.384000000041851, + "gpu_us": 0, + "annotation": false + }, + { + "op": "void at::native::index_elementwise_kernel<128, 4, at::native::gpu_index_kernel >(at::TensorIterator&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_put_kernel_impl >(at::TensorIterator&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1}>(long, at::native::gpu_index_kernel >(at::TensorIterator&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_put_kernel_impl >(at::TensorIterator&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 8, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 26.70399999982328, + "annotation": false + }, + { + "op": "aten::max", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 456 + ] + ], + "cpu_us": 182.3059999997131, + "gpu_us": 17.800999999788473, + "annotation": false + }, + { + "op": "void at::native::reduce_kernel<512, 1, at::native::ReduceOp >, unsigned int, long, 4, 4> >(at::native::ReduceOp >, unsigned int, long, 4, 4>)", + "device_type": "DeviceType.CUDA", + "count": 8, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 17.800999999788473, + "annotation": false + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [], + [], + [] + ], + "cpu_us": 98.42699999993056, + "gpu_us": 7.9729999999763095, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1 + ], + [] + ], + "cpu_us": 50.22500000017317, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::all", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 456 + ] + ], + "cpu_us": 128.04500000056578, + "gpu_us": 16.843000000109896, + "annotation": false + }, + { + "op": "void at::native::reduce_kernel<512, 1, at::native::ReduceOp, unsigned int, bool, 4, 4> >(at::native::ReduceOp, unsigned int, bool, 4, 4>)", + "device_type": "DeviceType.CUDA", + "count": 8, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 16.843000000109896, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 32 + ], + [] + ], + "cpu_us": 29.11700000053679, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 32 + ], + [], + [], + [] + ], + "cpu_us": 4.221999999936088, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 32 + ], + [] + ], + "cpu_us": 21.793000000019674, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 32 + ], + [], + [], + [] + ], + "cpu_us": 4.3810000001394656, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 1, + 32 + ], + [] + ], + "cpu_us": 17.30799999998999, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 1, + 32 + ], + [], + [], + [] + ], + "cpu_us": 8.144999999713036, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 1, + 32, + 1 + ], + [], + [], + [], + [] + ], + "cpu_us": 3.6470000001281733, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 1, + 32, + 1 + ], + [], + [] + ], + "cpu_us": 31.19400000006135, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 1, + 32, + 1 + ], + [], + [], + [] + ], + "cpu_us": 9.37500000007276, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 456 + ], + [] + ], + "cpu_us": 16.654000000417, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [], + [], + [], + [] + ], + "cpu_us": 13.070000000079744, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 32.30599999993865, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [ + 3, + 1, + 1, + 456 + ], + [] + ], + "cpu_us": 42.974999999743886, + "gpu_us": 16.040999999953783, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [], + [], + [], + [] + ], + "cpu_us": 2.987999999910244, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [ + 3, + 1, + 1, + 456 + ] + ], + "cpu_us": 110.67199999946752, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [], + [] + ], + "cpu_us": 23.10599999965052, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [], + [], + [] + ], + "cpu_us": 5.013000000049942, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [] + ], + "cpu_us": 39.99700000026496, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 32, + 1 + ], + [], + [] + ], + "cpu_us": 19.066999999937252, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [], + [] + ], + "cpu_us": 18.18800000019837, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [], + [], + [] + ], + "cpu_us": 3.3619999998336425, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [] + ], + "cpu_us": 9.829000000099768, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 1, + 456 + ], + [] + ], + "cpu_us": 15.628999999767984, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::bmm", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 32, + 1 + ], + [ + 3, + 1, + 456 + ] + ], + "cpu_us": 330.82300000006217, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "_native::bmm_triton_0", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 32, + 1 + ], + [ + 3, + 1, + 456 + ] + ], + "cpu_us": 1403.1730000003881, + "gpu_us": 11.845000000321306, + "annotation": false + }, + { + "op": "cuLaunchKernelEx", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [], + "cpu_us": 57.091999999873224, + "gpu_us": 0, + "annotation": false + }, + { + "op": "_bmm_outer_product_kernel", + "device_type": "DeviceType.CUDA", + "count": 8, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 11.845000000321306, + "annotation": false + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 32, + 456 + ], + [] + ], + "cpu_us": 16.09900000032212, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 32, + 456 + ], + [], + [] + ], + "cpu_us": 35.6900000001915, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 32, + 456 + ], + [], + [], + [] + ], + "cpu_us": 7.700000000113505, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::cos", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 456, + 32 + ] + ], + "cpu_us": 118.3530000000028, + "gpu_us": 14.405999999667984, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 3, + 1, + 456, + 32 + ], + [] + ], + "cpu_us": 182.9399999993766, + "gpu_us": 16.549000000115484, + "annotation": false + }, + { + "op": "aten::sin", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3, + 1, + 456, + 32 + ] + ], + "cpu_us": 85.72399999965273, + "gpu_us": 14.375999999974738, + "annotation": false + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "count": 48, + "input_shapes": [ + [ + 3, + 1, + 456, + 32 + ], + [], + [] + ], + "cpu_us": 169.25400000045192, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 48, + "input_shapes": [ + [ + 3, + 1, + 456, + 32 + ], + [], + [], + [] + ], + "cpu_us": 31.520999999760534, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [], + [], + [] + ], + "cpu_us": 180.39200000012352, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 448, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [], + [] + ], + "cpu_us": 328.15800000031595, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 1, + 456, + 11 + ], + [ + 1, + 456, + 11 + ], + [] + ], + "cpu_us": 105.59700000032899, + "gpu_us": 21.51700000007986, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 3104, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 14297.736999999863, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 1, + 456, + 10 + ], + [ + 1, + 456, + 10 + ], + [] + ], + "cpu_us": 73.73900000020512, + "gpu_us": 20.97100000042701, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 1, + 456, + 64 + ], + [], + [], + [], + [] + ], + "cpu_us": 22.965999999956694, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 1, + 456, + 64 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 66.57000000029802, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 16, + "input_shapes": [ + [ + 1, + 456, + 64 + ], + [ + 1, + 456, + 64 + ], + [] + ], + "cpu_us": 72.16299999972398, + "gpu_us": 16.00900000006368, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 2064, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [], + [] + ], + "cpu_us": 2818.4270000042743, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 2064, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 8746.418000000529, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::pow", + "device_type": "DeviceType.CPU", + "count": 520, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "cpu_us": 7397.041999999332, + "gpu_us": 1756.1520000018209, + "annotation": false + }, + { + "op": "aten::result_type", + "device_type": "DeviceType.CPU", + "count": 520, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "cpu_us": 225.76999999828695, + "gpu_us": 0, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::pow_tensor_scalar_kernel_impl(at::TensorIteratorBase&, float)::{lambda(float)#1}, std::array, false>(int, at::native::(anonymous namespace)::pow_tensor_scalar_kernel_impl(at::TensorIteratorBase&, float)::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 840, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 3153.805000000968, + "annotation": false + }, + { + "op": "aten::mean", + "device_type": "DeviceType.CPU", + "count": 520, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [] + ], + "cpu_us": 6402.54000000353, + "gpu_us": 2528.5739999996586, + "annotation": false + }, + { + "op": "void at::native::reduce_kernel<512, 1, at::native::ReduceOp, unsigned int, float, 4, 4> >(at::native::ReduceOp, unsigned int, float, 4, 4>)", + "device_type": "DeviceType.CUDA", + "count": 840, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 3877.2740000013873, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 520, + "input_shapes": [ + [ + 1, + 456, + 1 + ], + [], + [] + ], + "cpu_us": 4532.94000000041, + "gpu_us": 559.4910000023083, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::CUDAFunctorOnSelf_add, std::array, false>(int, at::native::CUDAFunctorOnSelf_add, std::array)", + "device_type": "DeviceType.CUDA", + "count": 1872, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1898.3499999966298, + "annotation": false + }, + { + "op": "aten::rsqrt", + "device_type": "DeviceType.CPU", + "count": 520, + "input_shapes": [ + [ + 1, + 456, + 1 + ] + ], + "cpu_us": 3864.1840000005614, + "gpu_us": 584.519999998025, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::rsqrt_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::rsqrt_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 1224, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1313.6250000005384, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 520, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 1 + ] + ], + "cpu_us": 4168.861000001329, + "gpu_us": 2075.932000001718, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 520, + "input_shapes": [ + [ + 2560 + ], + [], + [], + [], + [] + ], + "cpu_us": 908.7000000054832, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 520, + "input_shapes": [ + [ + 2560 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 2130.1879999973025, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 520, + "input_shapes": [ + [ + 2560 + ], + [ + 2560 + ], + [] + ], + "cpu_us": 2264.605000000447, + "gpu_us": 1188.7950000016135, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 520, + "input_shapes": [ + [ + 2560 + ], + [], + [] + ], + "cpu_us": 3933.3979999999283, + "gpu_us": 508.2919999980222, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 520, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560 + ] + ], + "cpu_us": 3737.792000002286, + "gpu_us": 2043.733000000284, + "annotation": false + }, + { + "op": "aten::type_as", + "device_type": "DeviceType.CPU", + "count": 520, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 2560 + ] + ], + "cpu_us": 1281.2449999969685, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 520, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 983.4869999981893, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 8192, + 2560 + ], + [] + ], + "cpu_us": 648.8650000004127, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 8192, + 2560 + ] + ], + "cpu_us": 625.0089999974734, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 8192, + 2560 + ], + [], + [] + ], + "cpu_us": 620.7720000013214, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 8192, + 2560 + ], + [], + [], + [] + ], + "cpu_us": 193.5970000002999, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 8192 + ] + ], + "cpu_us": 1581.6530000000494, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 2184, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "cpu_us": 3574.0029999993567, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 2184, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "cpu_us": 2451.4189999963564, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 8192 + ] + ], + "cpu_us": 4451.76100000435, + "gpu_us": 37389.67400000073, + "annotation": false + }, + { + "op": "ampere_bf16_s1688gemm_bf16_128x128_ldg8_f2f_stages_32x1_tn", + "device_type": "DeviceType.CUDA", + "count": 448, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 53036.59300000039, + "annotation": false + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "count": 320, + "input_shapes": [ + [ + 456, + 8192 + ], + [] + ], + "cpu_us": 276.4339999996737, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [], + [] + ], + "cpu_us": 682.4490000001533, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 768, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [], + [], + [] + ], + "cpu_us": 505.0799999982555, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 4096, + 2560 + ], + [] + ], + "cpu_us": 463.7050000026502, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 4096, + 2560 + ] + ], + "cpu_us": 331.5499999991589, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 4096, + 2560 + ], + [], + [] + ], + "cpu_us": 328.13700000048266, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 4096, + 2560 + ], + [], + [], + [] + ], + "cpu_us": 96.97299999988172, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 4096 + ] + ], + "cpu_us": 901.8389999980864, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 4096 + ] + ], + "cpu_us": 2353.98600000015, + "gpu_us": 15646.91899999966, + "annotation": false + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 456, + 4096 + ], + [] + ], + "cpu_us": 125.17099999928905, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 704, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [] + ], + "cpu_us": 1330.8619999959483, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [] + ], + "cpu_us": 671.3310000023921, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 32, + 2560 + ], + [] + ], + "cpu_us": 978.3380000003672, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 32, + 2560 + ] + ], + "cpu_us": 611.2329999963549, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 32, + 2560 + ], + [], + [] + ], + "cpu_us": 623.129000001747, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 32, + 2560 + ], + [], + [], + [] + ], + "cpu_us": 198.85800000045856, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 32 + ] + ], + "cpu_us": 1898.5989999990707, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 32 + ] + ], + "cpu_us": 6609.920999999231, + "gpu_us": 1919.2130000003235, + "annotation": false + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 456, + 32 + ], + [] + ], + "cpu_us": 301.594000000041, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::zero_", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 4 + ] + ], + "cpu_us": 715.0299999994313, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 4 + ], + [] + ], + "cpu_us": 1279.9800000001123, + "gpu_us": 163.37999999933527, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [], + [], + [], + [] + ], + "cpu_us": 1835.9840000001568, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 768, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [], + [], + [] + ], + "cpu_us": 597.3509999998059, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 4 + ], + [ + 1, + 8192, + 4 + ], + [] + ], + "cpu_us": 1461.9690000001283, + "gpu_us": 465.5129999999044, + "annotation": false + }, + { + "op": "void cutlass::Kernel2(cutlass_80_wmma_tensorop_bf16_s161616gemm_bf16_32x32_64x1_tn_align8::Params)", + "device_type": "DeviceType.CUDA", + "count": 384, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1299.9729999983829, + "annotation": false + }, + { + "op": "void cublasLt::splitKreduce_kernel<32, 16, int, __nv_bfloat16, __nv_bfloat16, float, __nv_bfloat16, false, __nv_bfloat16, __nv_bfloat16, __nv_bfloat16, true, false, false, false>(cublasLt::cublasSplitKParams, __nv_bfloat16 const*, __nv_bfloat16 const*, __nv_bfloat16*, __nv_bfloat16*, float const*, float const*, __nv_bfloat16 const*, __nv_bfloat16 const*, __nv_bfloat16*, void*, long, float*, int*, float*, float*, float const*, float const*, float const*, float const*, float const*)", + "device_type": "DeviceType.CUDA", + "count": 384, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 619.2400000019406, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::FillFunctor, std::array, false>(int, at::native::FillFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "count": 192, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 163.37999999933527, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#12}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#12}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 896, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 18415.768000000884, + "annotation": false + }, + { + "op": "aten::squeeze", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 8192, + 1, + 4 + ], + [] + ], + "cpu_us": 1014.023999999059, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 8192, + 1, + 4 + ], + [], + [], + [] + ], + "cpu_us": 296.4179999993212, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [], + [], + [], + [] + ], + "cpu_us": 192.04600000141363, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 8192, + 4 + ], + [] + ], + "cpu_us": 803.8079999984475, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 8192, + 4 + ], + [], + [], + [] + ], + "cpu_us": 124.77800000026764, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::conv1d", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [ + 8192, + 1, + 4 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 893.2190000014525, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::convolution", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [ + 8192, + 1, + 4 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 1241.0249999981024, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_convolution", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [ + 8192, + 1, + 4 + ], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 3767.500999997952, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::contiguous", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [] + ], + "cpu_us": 401.7190000033588, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [] + ], + "cpu_us": 861.9649999973626, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 514.9080000005051, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [ + 1, + 8192, + 456 + ], + [] + ], + "cpu_us": 1057.4900000005582, + "gpu_us": 8727.383999999423, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [] + ], + "cpu_us": 401.0399999989022, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 8192, + 1, + 4 + ], + [] + ], + "cpu_us": 318.07000000216067, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::_conv_depthwise2d", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 1, + 456 + ], + [ + 8192, + 1, + 1, + 4 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 2011.7720000001427, + "gpu_us": 8706.577999999907, + "annotation": false + }, + { + "op": "aten::squeeze", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 1, + 459 + ], + [] + ], + "cpu_us": 463.0960000003106, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 1, + 459 + ], + [], + [], + [] + ], + "cpu_us": 108.90099999996892, + "gpu_us": 0, + "annotation": false + }, + { + "op": "void at::native::(anonymous namespace)::conv_depthwise2d_forward_kernel_generic(torch::headeronly::detail::GenericPackedTensorAccessor, c10::BFloat16 const, 3ul, torch::headeronly::DefaultPtrTraits, int>, at::detail::IndexBoundsCheck<4ul, int>, c10::BFloat16 const, 4ul, torch::headeronly::DefaultPtrTraits, int>, torch::headeronly::detail::GenericPackedTensorAccessor, c10::BFloat16, 3ul, torch::headeronly::DefaultPtrTraits, int>, at::detail::IndexBoundsCheck<4ul, int>, c10::BFloat16, 4ul, torch::headeronly::DefaultPtrTraits, int>, torch::headeronly::detail::GenericPackedTensorAccessor, c10::BFloat16 const, 3ul, torch::headeronly::DefaultPtrTraits, int>, at::detail::IndexBoundsCheck<4ul, int>, c10::BFloat16 const, 4ul, torch::headeronly::DefaultPtrTraits, int>, torch::headeronly::detail::GenericPackedTensorAccessor, c10::BFloat16 const, 0ul, torch::headeronly::DefaultPtrTraits, int>, at::detail::IndexBoundsCheck<1ul, int>, c10::BFloat16 const, 1ul, torch::headeronly::DefaultPtrTraits, int>, bool, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int)", + "device_type": "DeviceType.CUDA", + "count": 192, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 8706.577999999907, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 459 + ], + [], + [], + [], + [] + ], + "cpu_us": 771.4430000017164, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 459 + ], + [], + [], + [] + ], + "cpu_us": 154.68399999760732, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::silu", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 456 + ] + ], + "cpu_us": 2166.3679999973247, + "gpu_us": 1534.9300000022631, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#6}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#6}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 192, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1534.9300000022631, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 8192, + 456 + ], + [], + [] + ], + "cpu_us": 765.7600000014936, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::split_with_sizes", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [], + [] + ], + "cpu_us": 1784.57000000251, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 2048 + ], + [] + ], + "cpu_us": 1604.9289999987668, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 2048 + ], + [], + [] + ], + "cpu_us": 686.3210000018589, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [], + [] + ], + "cpu_us": 188.37400000069465, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::sigmoid", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 456, + 32 + ] + ], + "cpu_us": 2023.13099999947, + "gpu_us": 259.2120000014402, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::sigmoid_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array, false>(int, at::native::sigmoid_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 256, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 470.8810000014055, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 32 + ], + [], + [], + [], + [] + ], + "cpu_us": 389.17099999707716, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 32 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 1048.227000002691, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 32 + ], + [ + 32 + ], + [] + ], + "cpu_us": 979.1470000006666, + "gpu_us": 280.8910000015894, + "annotation": false + }, + { + "op": "aten::exp", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 32 + ] + ], + "cpu_us": 1801.4909999999363, + "gpu_us": 217.282000000705, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::exp_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::exp_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 960, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1371.2410000006494, + "annotation": false + }, + { + "op": "aten::neg", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 32 + ] + ], + "cpu_us": 1682.9669999975013, + "gpu_us": 185.13099999977567, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 192, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 185.13099999977567, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [], + [], + [] + ], + "cpu_us": 264.3809999989462, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 753.0029999980034, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [ + 1, + 456, + 32 + ], + [] + ], + "cpu_us": 813.7170000023034, + "gpu_us": 373.84200000061537, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [ + 32 + ], + [] + ], + "cpu_us": 2131.574000002438, + "gpu_us": 561.0299999990821, + "annotation": false + }, + { + "op": "aten::softplus", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [] + ], + "cpu_us": 1814.038000000015, + "gpu_us": 340.0029999993567, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::softplus_kernel(at::TensorIteratorBase&, c10::Scalar const&, c10::Scalar const&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::(anonymous namespace)::softplus_kernel(at::TensorIteratorBase&, c10::Scalar const&, c10::Scalar const&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 192, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 340.0029999993567, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 32 + ], + [ + 1, + 456, + 32 + ] + ], + "cpu_us": 1692.5400000002264, + "gpu_us": 267.3160000009666, + "annotation": false + }, + { + "op": "aten::repeat_interleave", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 16, + 128 + ], + [], + [], + [] + ], + "cpu_us": 3140.7729999961157, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 16, + 128 + ], + [] + ], + "cpu_us": 1207.7410000003729, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 16, + 128 + ], + [], + [], + [] + ], + "cpu_us": 352.52100000088103, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 16, + 1, + 128 + ], + [], + [] + ], + "cpu_us": 1387.799000000814, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 16, + 1, + 128 + ], + [], + [], + [] + ], + "cpu_us": 269.3709999992716, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 16, + 2, + 128 + ], + [] + ], + "cpu_us": 1397.419000001304, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 16, + 2, + 128 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 669.5349999998725, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 16, + 2, + 128 + ], + [ + 1, + 456, + 16, + 2, + 128 + ], + [] + ], + "cpu_us": 2016.8140000006388, + "gpu_us": 8658.250000001237, + "annotation": false + }, + { + "op": "aten::flatten", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 16, + 2, + 128 + ], + [], + [] + ], + "cpu_us": 920.9440000013565, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 16, + 2, + 128 + ], + [] + ], + "cpu_us": 608.1599999999889, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 576, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [], + [] + ], + "cpu_us": 1679.8329999999114, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 576, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [], + [], + [] + ], + "cpu_us": 455.2269999993878, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 576, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [], + [], + [] + ], + "cpu_us": 881.818000001731, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 576, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 2124.5019999986107, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 1152, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [ + 1, + 32, + 456, + 128 + ], + [] + ], + "cpu_us": 5799.4109999971115, + "gpu_us": 7383.074999999735, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 32 + ], + [], + [] + ], + "cpu_us": 1112.7399999987683, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 456 + ], + [], + [], + [], + [] + ], + "cpu_us": 447.9709999992774, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 456 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 607.4980000012292, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 576, + "input_shapes": [ + [ + 1, + 32, + 456 + ], + [ + 1, + 32, + 456 + ], + [] + ], + "cpu_us": 2594.0239999976766, + "gpu_us": 966.3700000019162, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [ + 1, + 32, + 456, + 128 + ] + ], + "cpu_us": 2948.803999998854, + "gpu_us": 1878.6690000023955, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::BinaryFunctor >, std::array, false>(int, at::native::BinaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "count": 768, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 3334.429000004413, + "annotation": false + }, + { + "op": "aten::sum", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [], + [] + ], + "cpu_us": 4638.598999998678, + "gpu_us": 1799.9040000020032, + "annotation": false + }, + { + "op": "void at::native::reduce_kernel<512, 1, at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(float, float)#1}>, unsigned int, float, 4, 4> >(at::native::ReduceOp::operator()(at::TensorIterator&)::{lambda(float, float)#1}>, unsigned int, float, 4, 4>)", + "device_type": "DeviceType.CUDA", + "count": 384, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1799.9040000020032, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 456, + 1 + ], + [], + [] + ], + "cpu_us": 3274.435000000958, + "gpu_us": 381.356999998854, + "annotation": false + }, + { + "op": "aten::rsqrt", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 456, + 1 + ] + ], + "cpu_us": 2660.799999996816, + "gpu_us": 392.215000001539, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [ + 1, + 32, + 456, + 1 + ] + ], + "cpu_us": 2834.143000003358, + "gpu_us": 1962.1960000028485, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [] + ], + "cpu_us": 1635.1980000008334, + "gpu_us": 921.6350000006641, + "annotation": false + }, + { + "op": "aten::pad", + "device_type": "DeviceType.CPU", + "count": 576, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [], + [] + ], + "cpu_us": 1285.0120000060706, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::constant_pad_nd", + "device_type": "DeviceType.CPU", + "count": 576, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [] + ], + "cpu_us": 3934.1920000021055, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "count": 576, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [] + ], + "cpu_us": 2317.1149999982445, + "gpu_us": 2339.538000000088, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::FillFunctor, std::array, false>(int, at::native::FillFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "count": 1536, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 4043.303000000582, + "annotation": false + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "count": 576, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [], + [], + [] + ], + "cpu_us": 1338.8190000010509, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 768, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [], + [], + [], + [] + ], + "cpu_us": 2337.627000001361, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 768, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [], + [], + [] + ], + "cpu_us": 541.1909999989439, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::pad", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 456 + ], + [], + [], + [] + ], + "cpu_us": 575.1489999966143, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::constant_pad_nd", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 456 + ], + [], + [] + ], + "cpu_us": 2140.575000000754, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [] + ], + "cpu_us": 1327.5680000010034, + "gpu_us": 314.84900000016205, + "annotation": false + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [], + [], + [] + ], + "cpu_us": 544.3510000007955, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [], + [], + [], + [] + ], + "cpu_us": 763.7260000000388, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 768, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [], + [], + [] + ], + "cpu_us": 520.1359999985289, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [] + ], + "cpu_us": 1142.2120000016002, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [ + 1, + 32, + 512, + 1 + ] + ], + "cpu_us": 3001.8470000005764, + "gpu_us": 2151.672999999093, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 768, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [] + ], + "cpu_us": 1269.1460000037914, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 768, + "input_shapes": [ + [ + 1, + 32, + 512, + 128 + ], + [] + ], + "cpu_us": 1108.5689999974566, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [] + ], + "cpu_us": 342.5690000005852, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 512 + ], + [] + ], + "cpu_us": 271.091000000466, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::ones", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [], + [], + [], + [], + [] + ], + "cpu_us": 682.8939999980066, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 64, + 64 + ], + [] + ], + "cpu_us": 964.6420000014477, + "gpu_us": 165.3659999985539, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::FillFunctor, std::array, false>(int, at::native::FillFunctor, std::array)", + "device_type": "DeviceType.CUDA", + "count": 192, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 165.3659999985539, + "annotation": false + }, + { + "op": "aten::triu", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 64, + 64 + ], + [] + ], + "cpu_us": 2057.0889999975916, + "gpu_us": 340.0970000002999, + "annotation": false + }, + { + "op": "void at::native::triu_tril_kernel(at::cuda::detail::TensorInfo, at::cuda::detail::TensorInfo, long, long, int)", + "device_type": "DeviceType.CUDA", + "count": 192, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 340.0970000002999, + "annotation": false + }, + { + "op": "aten::cumsum", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [], + [] + ], + "cpu_us": 2218.229000000283, + "gpu_us": 432.927000002368, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [], + [], + [], + [] + ], + "cpu_us": 88.71899999861489, + "gpu_us": 0, + "annotation": false + }, + { + "op": "void at::native::tensor_kernel_scan_innermost_dim >(float*, float const*, unsigned int, unsigned int, unsigned int, float, std::plus)", + "device_type": "DeviceType.CUDA", + "count": 192, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 432.927000002368, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 960, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [] + ], + "cpu_us": 2907.070999998221, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 1344, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [], + [], + [] + ], + "cpu_us": 973.5570000029402, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 1 + ], + [ + 1, + 32, + 8, + 1, + 64 + ], + [] + ], + "cpu_us": 2089.5229999994626, + "gpu_us": 663.6310000002122, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast >(at::TensorIteratorBase&, at::native::CUDAFunctor_add const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 1920, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 5762.865999999485, + "annotation": false + }, + { + "op": "aten::masked_fill", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [ + 64, + 64 + ], + [] + ], + "cpu_us": 1858.004000000219, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [], + [] + ], + "cpu_us": 547.5679999992135, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 2112, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [], + [], + [] + ], + "cpu_us": 1271.9569999999512, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 64, + 64 + ], + [], + [] + ], + "cpu_us": 772.1509999982372, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 64, + 64 + ], + [], + [], + [] + ], + "cpu_us": 267.28900000111025, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [] + ], + "cpu_us": 604.2540000012959, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 289.30400000017835, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [ + 1, + 32, + 8, + 64, + 64 + ], + [] + ], + "cpu_us": 725.161999999531, + "gpu_us": 593.4600000015926, + "annotation": false + }, + { + "op": "aten::masked_fill_", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [ + 64, + 64 + ], + [] + ], + "cpu_us": 2058.732999999236, + "gpu_us": 733.631999999372, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::(anonymous namespace)::masked_fill_kernel(at::TensorIterator&, c10::Scalar const&)::{lambda()#1}::operator()() const::{lambda()#7}::operator()() const::{lambda(float, bool)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::(anonymous namespace)::masked_fill_kernel(at::TensorIterator&, c10::Scalar const&)::{lambda()#1}::operator()() const::{lambda()#7}::operator()() const::{lambda(float, bool)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 192, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 733.631999999372, + "annotation": false + }, + { + "op": "aten::exp", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ] + ], + "cpu_us": 1481.4130000002333, + "gpu_us": 565.4360000017914, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 1152, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [] + ], + "cpu_us": 2862.562999998496, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 9216, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [], + [] + ], + "cpu_us": 5436.529000003487, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [ + 1, + 32, + 8, + 128, + 64 + ] + ], + "cpu_us": 4954.971000000543, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [] + ], + "cpu_us": 1143.6979999980394, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 576, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "cpu_us": 1540.099999997139, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "cpu_us": 533.2520000002114, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [], + [] + ], + "cpu_us": 846.4710000028717, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [], + [], + [] + ], + "cpu_us": 231.58699999975215, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [] + ], + "cpu_us": 1198.519999999393, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [], + [] + ], + "cpu_us": 536.303999999509, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::bmm", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 256, + 64, + 128 + ], + [ + 256, + 128, + 64 + ] + ], + "cpu_us": 16531.03200000021, + "gpu_us": 9189.163000000379, + "annotation": false + }, + { + "op": "ampere_sgemm_128x128_tn", + "device_type": "DeviceType.CUDA", + "count": 1920, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 21932.84000000298, + "annotation": false + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 256, + 64, + 64 + ], + [] + ], + "cpu_us": 458.41799999933573, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [ + 1, + 32, + 8, + 64, + 64 + ] + ], + "cpu_us": 3084.456999998394, + "gpu_us": 1455.7600000020175, + "annotation": false + }, + { + "op": "aten::exp", + "device_type": "DeviceType.CPU", + "count": 576, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ] + ], + "cpu_us": 4158.825999997236, + "gpu_us": 588.522999998153, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 576, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [ + 1, + 32, + 8, + 64, + 1 + ] + ], + "cpu_us": 4655.879999999961, + "gpu_us": 6464.013000000501, + "annotation": false + }, + { + "op": "aten::linalg_solve_triangular", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [], + [] + ], + "cpu_us": 9139.460000000865, + "gpu_us": 22559.872000000134, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [], + [] + ], + "cpu_us": 729.9480000003969, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose_", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [], + [] + ], + "cpu_us": 918.5330000005779, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided_", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 8, + 128, + 64 + ], + [], + [], + [] + ], + "cpu_us": 812.4519999984332, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 576, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "cpu_us": 3137.2399999991467, + "gpu_us": 7214.019999997778, + "annotation": false + }, + { + "op": "aten::arange", + "device_type": "DeviceType.CPU", + "count": 768, + "input_shapes": [ + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 2273.155000000668, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "void batch_trsm_left_kernel(cublasTrsmBatchParams2, float, float const*, int)", + "device_type": "DeviceType.CUDA", + "count": 384, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 22559.872000000134, + "annotation": false + }, + { + "op": "aten::zero_", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ] + ], + "cpu_us": 1299.4480000014446, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [] + ], + "cpu_us": 1748.6039999996574, + "gpu_us": 591.5090000010532, + "annotation": false + }, + { + "op": "aten::zeros_like", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 594.5250000001688, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 868.4189999985974, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::zero_", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ] + ], + "cpu_us": 497.9500000007247, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::fill_", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "cpu_us": 677.7539999992878, + "gpu_us": 797.4069999992789, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [], + [], + [], + [] + ], + "cpu_us": 967.5900000001275, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 1 + ], + [ + 1, + 32, + 8, + 64 + ], + [] + ], + "cpu_us": 1795.6999999997352, + "gpu_us": 261.52600000005623, + "annotation": false + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64 + ], + [], + [] + ], + "cpu_us": 995.9519999980112, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::exp", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8 + ] + ], + "cpu_us": 1489.8050000007643, + "gpu_us": 281.0520000006218, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::exp_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::exp_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 192, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 281.0520000006218, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8 + ], + [] + ], + "cpu_us": 466.7249999977357, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8 + ], + [], + [], + [] + ], + "cpu_us": 133.97600000171224, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 1 + ], + [] + ], + "cpu_us": 657.0109999987471, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 1 + ], + [], + [], + [] + ], + "cpu_us": 121.22600000016973, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "count": 7680, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [], + [] + ], + "cpu_us": 22434.09599998982, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 3072, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [ + 1, + 32, + 128, + 128 + ] + ], + "cpu_us": 31357.087999992946, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 6144, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [], + [] + ], + "cpu_us": 14789.008000000205, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 7680, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [], + [], + [] + ], + "cpu_us": 4697.042999997924, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 6144, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [] + ], + "cpu_us": 12657.12399999905, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "count": 6144, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [], + [] + ], + "cpu_us": 5442.444999999032, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 3072, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [], + [] + ], + "cpu_us": 6704.680999999167, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 3072, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [], + [], + [] + ], + "cpu_us": 1345.062000002261, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 3072, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [] + ], + "cpu_us": 4279.650000002701, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 3072, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [] + ], + "cpu_us": 3101.9379999984667, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::bmm", + "device_type": "DeviceType.CPU", + "count": 3072, + "input_shapes": [ + [ + 32, + 64, + 128 + ], + [ + 32, + 128, + 128 + ] + ], + "cpu_us": 59919.90000000317, + "gpu_us": 37705.22000000463, + "annotation": false + }, + { + "op": "ampere_sgemm_128x128_nt", + "device_type": "DeviceType.CUDA", + "count": 1536, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 18558.048999999897, + "annotation": false + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "count": 4608, + "input_shapes": [ + [ + 32, + 64, + 128 + ], + [] + ], + "cpu_us": 3349.1840000011, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::sub", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [ + 1, + 32, + 64, + 128 + ], + [] + ], + "cpu_us": 12366.453000002904, + "gpu_us": 4837.708999999217, + "annotation": false + }, + { + "op": "ampere_sgemm_128x128_nn", + "device_type": "DeviceType.CUDA", + "count": 1536, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 19147.17100000473, + "annotation": false + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 64 + ], + [], + [] + ], + "cpu_us": 4249.898000002373, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 64, + 64 + ], + [ + 1, + 32, + 64, + 128 + ] + ], + "cpu_us": 15020.657999998497, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 64, + 64 + ], + [], + [] + ], + "cpu_us": 3847.7829999971145, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 64, + 64 + ], + [], + [], + [] + ], + "cpu_us": 1070.9849999996222, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 64, + 64 + ], + [] + ], + "cpu_us": 3222.9389999965497, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 64, + 64 + ], + [], + [] + ], + "cpu_us": 1390.2300000010728, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::bmm", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 32, + 64, + 64 + ], + [ + 32, + 64, + 128 + ] + ], + "cpu_us": 27781.143000001408, + "gpu_us": 12743.6770000026, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [ + 1, + 32, + 64, + 128 + ], + [] + ], + "cpu_us": 10824.931999993903, + "gpu_us": 2390.0540000009205, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [ + 1, + 32, + 64, + 128 + ], + [] + ], + "cpu_us": 8694.459000003742, + "gpu_us": 3593.3459999998595, + "annotation": false + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 8, + 1, + 1 + ], + [], + [] + ], + "cpu_us": 4459.383000003669, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 8, + 1, + 1 + ], + [], + [], + [] + ], + "cpu_us": 862.1369999986782, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [ + 1, + 32, + 1, + 1 + ] + ], + "cpu_us": 12031.911000000371, + "gpu_us": 3906.115000001839, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 64, + 128 + ], + [], + [] + ], + "cpu_us": 4148.096000008067, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 128, + 64 + ], + [ + 1, + 32, + 64, + 128 + ] + ], + "cpu_us": 14816.38300000332, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::expand", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 128, + 64 + ], + [], + [] + ], + "cpu_us": 3841.652000001268, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 128, + 64 + ], + [], + [], + [] + ], + "cpu_us": 982.8589999991527, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 128, + 64 + ], + [] + ], + "cpu_us": 3250.940000000308, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::_reshape_alias", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 128, + 64 + ], + [], + [] + ], + "cpu_us": 1454.4089999976277, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::bmm", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 32, + 128, + 64 + ], + [ + 32, + 64, + 128 + ] + ], + "cpu_us": 29737.80700000249, + "gpu_us": 12233.507000002792, + "annotation": false + }, + { + "op": "ampere_sgemm_128x128_tt", + "device_type": "DeviceType.CUDA", + "count": 1536, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 12233.507000002792, + "annotation": false + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 32, + 128, + 128 + ], + [] + ], + "cpu_us": 1135.8160000011994, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 1536, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [ + 1, + 32, + 128, + 128 + ], + [] + ], + "cpu_us": 10533.256999996796, + "gpu_us": 3420.8589999993274, + "annotation": false + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "cpu_us": 1008.5700000028592, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 8, + 64, + 128 + ], + [] + ], + "cpu_us": 170.6299999995099, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [] + ], + "cpu_us": 530.9019999996817, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 456, + 128 + ], + [], + [], + [] + ], + "cpu_us": 158.67000000053667, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [], + [], + [], + [] + ], + "cpu_us": 444.53300000043237, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 1024.686999999758, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [ + 1, + 456, + 32, + 128 + ], + [] + ], + "cpu_us": 1163.1860000011948, + "gpu_us": 897.3420000007172, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::bfloat16_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda(float)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::bfloat16_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda(float)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 192, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 897.3420000007172, + "annotation": false + }, + { + "op": "aten::zeros_like", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 738.7839999999414, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 521.8779999992257, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 32, + 128, + 128 + ], + [ + 1, + 32, + 128, + 128 + ], + [] + ], + "cpu_us": 791.2059999997582, + "gpu_us": 354.3110000004526, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [] + ], + "cpu_us": 833.1229999992356, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 384, + "input_shapes": [ + [ + 1, + 456, + 32, + 128 + ], + [] + ], + "cpu_us": 647.9080000018876, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 960, + "input_shapes": [ + [ + 14592, + 128 + ], + [], + [], + [], + [] + ], + "cpu_us": 1681.370999999679, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 768, + "input_shapes": [ + [ + 14592, + 128 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 3389.398000002082, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 768, + "input_shapes": [ + [ + 14592, + 128 + ], + [ + 14592, + 128 + ], + [] + ], + "cpu_us": 3695.8160000017233, + "gpu_us": 3901.116000000882, + "annotation": false + }, + { + "op": "aten::pow", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 14592, + 128 + ], + [] + ], + "cpu_us": 3045.385999997714, + "gpu_us": 969.2799999987037, + "annotation": false + }, + { + "op": "aten::result_type", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 14592, + 128 + ], + [] + ], + "cpu_us": 160.45100000072853, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mean", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 14592, + 128 + ], + [], + [], + [] + ], + "cpu_us": 3104.870999999286, + "gpu_us": 908.8420000011392, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 14592, + 1 + ], + [], + [] + ], + "cpu_us": 2077.0409999997937, + "gpu_us": 195.83500000019558, + "annotation": false + }, + { + "op": "aten::rsqrt", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 14592, + 1 + ] + ], + "cpu_us": 1728.922000000457, + "gpu_us": 200.236000000863, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 14592, + 128 + ], + [ + 14592, + 1 + ] + ], + "cpu_us": 1715.9819999995816, + "gpu_us": 988.1509999990813, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 128 + ], + [ + 14592, + 128 + ] + ], + "cpu_us": 1733.0539999994653, + "gpu_us": 888.1400000015856, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 448, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1461.0000000011496, + "annotation": false + }, + { + "op": "aten::silu", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 14592, + 128 + ] + ], + "cpu_us": 1915.0540000009496, + "gpu_us": 985.1039999987843, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array, false>(int, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 192, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 985.1039999987843, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 14592, + 128 + ], + [ + 14592, + 128 + ] + ], + "cpu_us": 1555.154000000868, + "gpu_us": 1321.9630000003235, + "annotation": false + }, + { + "op": "void at::native::unrolled_elementwise_kernel >, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1> >(int, at::native::BinaryFunctor >, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1>)", + "device_type": "DeviceType.CUDA", + "count": 192, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1321.9630000003235, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 14592, + 128 + ], + [] + ], + "cpu_us": 345.55700000052457, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 14592, + 128 + ], + [] + ], + "cpu_us": 353.8339999995369, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 2560, + 4096 + ], + [] + ], + "cpu_us": 852.6569999991771, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 4096, + 2560 + ] + ], + "cpu_us": 1779.125999999902, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 456, + 4096 + ], + [ + 4096, + 2560 + ] + ], + "cpu_us": 6842.653000001374, + "gpu_us": 23074.021999999648, + "annotation": false + }, + { + "op": "ampere_bf16_s1688gemm_bf16_64x64_sliced1x4_ldg8_f2f_tn", + "device_type": "DeviceType.CUDA", + "count": 256, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 22950.46500000026, + "annotation": false + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "count": 832, + "input_shapes": [ + [ + 456, + 2560 + ], + [] + ], + "cpu_us": 717.5969999991066, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 832, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1, + 456, + 2560 + ], + [] + ], + "cpu_us": 6324.563000001115, + "gpu_us": 4785.1650000000955, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 9216, + 2560 + ], + [] + ], + "cpu_us": 1439.8809999989462, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 9216, + 2560 + ] + ], + "cpu_us": 1156.6270000001678, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 9216, + 2560 + ], + [], + [] + ], + "cpu_us": 1139.705999998696, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 9216, + 2560 + ], + [], + [], + [] + ], + "cpu_us": 328.08700000098906, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 9216 + ] + ], + "cpu_us": 2931.6510000023845, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 9216 + ] + ], + "cpu_us": 8314.474000001108, + "gpu_us": 90946.400999997, + "annotation": false + }, + { + "op": "ampere_bf16_s1688gemm_bf16_64x128_sliced1x2_ldg8_f2f_tn", + "device_type": "DeviceType.CUDA", + "count": 768, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 135649.5199999984, + "annotation": false + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "count": 1024, + "input_shapes": [ + [ + 456, + 9216 + ], + [] + ], + "cpu_us": 756.3490000013262, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "count": 704, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [], + [] + ], + "cpu_us": 220.5099999988306, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 704, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 16, + 2560 + ], + [] + ], + "cpu_us": 1595.6140000059822, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 704, + "input_shapes": [ + [ + 16, + 2560 + ] + ], + "cpu_us": 1387.3009999961942, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 704, + "input_shapes": [ + [ + 16, + 2560 + ], + [], + [] + ], + "cpu_us": 1752.337999999916, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 704, + "input_shapes": [ + [ + 16, + 2560 + ], + [], + [], + [] + ], + "cpu_us": 432.5560000005062, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 704, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 16 + ] + ], + "cpu_us": 3674.547999998773, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 704, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 16 + ] + ], + "cpu_us": 10801.014000000432, + "gpu_us": 5427.183999998437, + "annotation": false + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "count": 1024, + "input_shapes": [ + [ + 456, + 16 + ], + [] + ], + "cpu_us": 731.5820000009699, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 9216, + 16 + ], + [] + ], + "cpu_us": 1130.2720000041008, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 9216, + 16 + ] + ], + "cpu_us": 961.9399999976595, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 9216, + 16 + ], + [], + [] + ], + "cpu_us": 917.725000000617, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 9216, + 16 + ], + [], + [], + [] + ], + "cpu_us": 307.7679999992397, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 16, + 9216 + ] + ], + "cpu_us": 2513.068999996627, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 1024, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [] + ], + "cpu_us": 1460.0440000027302, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 1024, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [] + ], + "cpu_us": 952.9719999978115, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 456, + 16 + ], + [ + 16, + 9216 + ] + ], + "cpu_us": 5963.698000000528, + "gpu_us": 6153.779999999024, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [] + ], + "cpu_us": 4614.488999999361, + "gpu_us": 4933.401000000682, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 1, + 456, + 9216 + ], + [] + ], + "cpu_us": 3801.765999995885, + "gpu_us": 9426.971000000602, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 768, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [], + [], + [], + [] + ], + "cpu_us": 1291.8840000000055, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 768, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 2986.8489999982266, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 768, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 1, + 456, + 9216 + ], + [] + ], + "cpu_us": 3401.342000001867, + "gpu_us": 5871.197000000931, + "annotation": false + }, + { + "op": "aten::silu", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 1, + 456, + 9216 + ] + ], + "cpu_us": 2232.3199999984645, + "gpu_us": 1488.989000001282, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#6}::operator()() const::{lambda(c10::BFloat16)#1}, std::array, false>(int, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#6}::operator()() const::{lambda(c10::BFloat16)#1}, std::array)", + "device_type": "DeviceType.CUDA", + "count": 256, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1488.989000001282, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 1, + 456, + 9216 + ] + ], + "cpu_us": 1874.3360000009125, + "gpu_us": 3733.0350000002945, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 2560, + 9216 + ], + [] + ], + "cpu_us": 712.5170000019571, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 2560, + 9216 + ] + ], + "cpu_us": 460.48799999761104, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 2560, + 9216 + ], + [], + [] + ], + "cpu_us": 480.5910000035947, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 2560, + 9216 + ], + [], + [], + [] + ], + "cpu_us": 149.10399999767833, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 9216, + 2560 + ] + ], + "cpu_us": 1359.7440000014903, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [] + ], + "cpu_us": 713.9649999996327, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 512, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [] + ], + "cpu_us": 506.54499999915424, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 456, + 9216 + ], + [ + 9216, + 2560 + ] + ], + "cpu_us": 3608.5359999979555, + "gpu_us": 45113.66600000023, + "annotation": false + }, + { + "op": "void at::native::vectorized_elementwise_kernel<4, at::native::BinaryFunctor >, std::array, false>(int, at::native::BinaryFunctor >, std::array)", + "device_type": "DeviceType.CUDA", + "count": 320, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 3956.717000000339, + "annotation": false + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [], + [] + ], + "cpu_us": 56.044000000707456, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 16, + 9216 + ], + [] + ], + "cpu_us": 583.2509999986651, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 16, + 9216 + ] + ], + "cpu_us": 410.63500000187196, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 16, + 9216 + ], + [], + [] + ], + "cpu_us": 449.3879999988567, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 16, + 9216 + ], + [], + [], + [] + ], + "cpu_us": 171.19599999970524, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 1, + 456, + 9216 + ], + [ + 9216, + 16 + ] + ], + "cpu_us": 1225.5680000006687, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 456, + 9216 + ], + [ + 9216, + 16 + ] + ], + "cpu_us": 3412.071999998705, + "gpu_us": 3528.1450000008044, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 320, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 2560, + 16 + ], + [] + ], + "cpu_us": 742.4900000033085, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 320, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 16, + 2560 + ] + ], + "cpu_us": 1654.1929999986314, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 320, + "input_shapes": [ + [ + 456, + 16 + ], + [ + 16, + 2560 + ] + ], + "cpu_us": 3542.352000001425, + "gpu_us": 1462.0760000017617, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 320, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [] + ], + "cpu_us": 2648.4170000015, + "gpu_us": 1055.5769999995682, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 8192, + 16 + ], + [] + ], + "cpu_us": 143.74199999925622, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 8192, + 16 + ] + ], + "cpu_us": 115.16200000088429, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 8192, + 16 + ], + [], + [] + ], + "cpu_us": 104.30199999905017, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 8192, + 16 + ], + [], + [], + [] + ], + "cpu_us": 38.57400000038615, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 16, + 8192 + ] + ], + "cpu_us": 286.7470000010071, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 456, + 16 + ], + [ + 16, + 8192 + ] + ], + "cpu_us": 1252.0220000004483, + "gpu_us": 792.036000001317, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [] + ], + "cpu_us": 559.9420000002865, + "gpu_us": 591.120000001305, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [ + 1, + 456, + 8192 + ], + [] + ], + "cpu_us": 465.09000000025844, + "gpu_us": 987.9169999995647, + "annotation": false + }, + { + "op": "void cutlass::Kernel2(cutlass_80_simt_sgemm_256x128_8x4_tn_align1::Params)", + "device_type": "DeviceType.CUDA", + "count": 64, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 792.036000001317, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [], + [], + [], + [] + ], + "cpu_us": 157.91299999892362, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 242.3210000013496, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [ + 1, + 456, + 8192 + ], + [] + ], + "cpu_us": 275.23999999921944, + "gpu_us": 364.5000000002183, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 8192 + ], + [] + ], + "cpu_us": 121.8950000001496, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::chunk", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16, + 512 + ], + [], + [] + ], + "cpu_us": 259.432999999437, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::split", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16, + 512 + ], + [], + [] + ], + "cpu_us": 416.72100000044156, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::narrow", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 16, + 512 + ], + [], + [], + [] + ], + "cpu_us": 314.4849999993312, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 16, + 512 + ], + [], + [], + [], + [] + ], + "cpu_us": 290.033999999956, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 16, + 512 + ], + [], + [], + [] + ], + "cpu_us": 103.71600000064063, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "cpu_us": 558.991000000271, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::clone", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "cpu_us": 565.0139999993698, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::empty_like", + "device_type": "DeviceType.CPU", + "count": 192, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 425.2230000005511, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "cpu_us": 1405.904000004084, + "gpu_us": 1189.197000000815, + "annotation": false + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "cpu_us": 52.59399999991001, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "cpu_us": 229.29600000032224, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [], + [] + ], + "cpu_us": 106.0059999988298, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 605.2829999993264, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::pow", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "cpu_us": 748.8260000006267, + "gpu_us": 318.51799999995274, + "annotation": false + }, + { + "op": "aten::result_type", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "cpu_us": 24.02800000012212, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mean", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [] + ], + "cpu_us": 744.3180000007414, + "gpu_us": 280.06400000021677, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16, + 1 + ], + [], + [] + ], + "cpu_us": 542.0209999995859, + "gpu_us": 64.60899999922549, + "annotation": false + }, + { + "op": "aten::rsqrt", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16, + 1 + ] + ], + "cpu_us": 453.2859999988141, + "gpu_us": 66.72999999986496, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [ + 1, + 456, + 16, + 1 + ] + ], + "cpu_us": 511.18700000034005, + "gpu_us": 330.5870000006398, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 256 + ], + [], + [], + [], + [] + ], + "cpu_us": 172.02899999885994, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 256 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 581.0180000004766, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 256 + ], + [ + 256 + ], + [] + ], + "cpu_us": 559.9390000002459, + "gpu_us": 229.5040000005538, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 256 + ], + [], + [] + ], + "cpu_us": 913.8519999982818, + "gpu_us": 122.81299999819021, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [ + 256 + ] + ], + "cpu_us": 450.955999998303, + "gpu_us": 336.73500000085915, + "annotation": false + }, + { + "op": "aten::type_as", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [ + 1, + 456, + 16, + 256 + ] + ], + "cpu_us": 148.37899999972433, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 101.87800000043353, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [] + ], + "cpu_us": 365.3820000006526, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [], + [], + [] + ], + "cpu_us": 89.23699999949895, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 1024, + 2560 + ], + [] + ], + "cpu_us": 333.34300000118674, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1024, + 2560 + ] + ], + "cpu_us": 226.59299999799987, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1024, + 2560 + ], + [], + [] + ], + "cpu_us": 314.53600000166625, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1024, + 2560 + ], + [], + [], + [] + ], + "cpu_us": 69.96899999992456, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 1024 + ] + ], + "cpu_us": 702.4059999995516, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 1024 + ] + ], + "cpu_us": 2008.0540000002948, + "gpu_us": 2648.4800000000105, + "annotation": false + }, + { + "op": "ampere_bf16_s16816gemm_bf16_64x64_sliced1x2_ldg8_f2f_stages_64x5_tn", + "device_type": "DeviceType.CUDA", + "count": 128, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 2648.4800000000105, + "annotation": false + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 456, + 1024 + ], + [] + ], + "cpu_us": 185.95400000049267, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 1024, + 16 + ], + [] + ], + "cpu_us": 320.629999999408, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 16 + ], + [ + 16, + 1024 + ] + ], + "cpu_us": 623.6490000020567, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 456, + 16 + ], + [ + 16, + 1024 + ] + ], + "cpu_us": 1656.4629999985627, + "gpu_us": 3997.720000001864, + "annotation": false + }, + { + "op": "ampere_sgemm_64x64_tn", + "device_type": "DeviceType.CUDA", + "count": 128, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 3947.6130000007397, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [] + ], + "cpu_us": 1149.3160000009375, + "gpu_us": 220.85799999933806, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [ + 1, + 456, + 1024 + ], + [] + ], + "cpu_us": 888.3050000003132, + "gpu_us": 431.53999999967346, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [], + [], + [], + [] + ], + "cpu_us": 192.89999999837892, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 500.55899999974645, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [ + 1, + 456, + 1024 + ], + [] + ], + "cpu_us": 581.7890000019397, + "gpu_us": 194.4169999994192, + "annotation": false + }, + { + "op": "aten::view", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 1024 + ], + [] + ], + "cpu_us": 216.19300000004296, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [], + [] + ], + "cpu_us": 106.26799999955983, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 498.93199999989884, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [ + 1, + 456, + 4, + 256 + ], + [] + ], + "cpu_us": 551.2509999990143, + "gpu_us": 248.96999999982654, + "annotation": false + }, + { + "op": "aten::pow", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [] + ], + "cpu_us": 659.7759999990521, + "gpu_us": 109.85500000049069, + "annotation": false + }, + { + "op": "aten::result_type", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [] + ], + "cpu_us": 21.65100000043458, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mean", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [] + ], + "cpu_us": 702.4679999999207, + "gpu_us": 159.79400000037276, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4, + 1 + ], + [], + [] + ], + "cpu_us": 505.2959999986342, + "gpu_us": 65.95299999983399, + "annotation": false + }, + { + "op": "aten::rsqrt", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4, + 1 + ] + ], + "cpu_us": 433.1400000001886, + "gpu_us": 69.92400000024645, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [ + 1, + 456, + 4, + 1 + ] + ], + "cpu_us": 468.67899999911606, + "gpu_us": 157.82299999945099, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [ + 256 + ] + ], + "cpu_us": 488.72800000007555, + "gpu_us": 165.88699999918754, + "annotation": false + }, + { + "op": "aten::type_as", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [ + 1, + 456, + 4, + 256 + ] + ], + "cpu_us": 107.81599999849277, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 104.95699999970384, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [] + ], + "cpu_us": 576.4670000004553, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [] + ], + "cpu_us": 112.44100000012259, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::unsqueeze", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 64 + ], + [] + ], + "cpu_us": 444.10499999929743, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 456, + 64 + ], + [], + [], + [] + ], + "cpu_us": 93.00599999971746, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 16, + 456, + 256 + ], + [], + [], + [], + [] + ], + "cpu_us": 488.6169999992999, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 1, + 16, + 456, + 256 + ], + [], + [], + [] + ], + "cpu_us": 180.06300000092597, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 4, + 456, + 256 + ], + [], + [], + [], + [] + ], + "cpu_us": 389.15600000145787, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 256, + "input_shapes": [ + [ + 1, + 4, + 456, + 256 + ], + [], + [], + [] + ], + "cpu_us": 137.86999999871477, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 16, + 456, + 64 + ], + [ + 1, + 1, + 456, + 64 + ] + ], + "cpu_us": 1239.595999999554, + "gpu_us": 344.60499999966123, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 16, + 456, + 64 + ], + [], + [], + [], + [] + ], + "cpu_us": 473.7469999989844, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 16, + 456, + 64 + ], + [], + [], + [] + ], + "cpu_us": 80.12600000048405, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::neg", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 16, + 456, + 32 + ] + ], + "cpu_us": 762.4799999992247, + "gpu_us": 124.90100000009988, + "annotation": false + }, + { + "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#9}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::neg_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#9}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 128, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 232.19300000110525, + "annotation": false + }, + { + "op": "void at::native::(anonymous namespace)::CatArrayBatchedCopy, unsigned int, 4, 64, 64>(at::native::(anonymous namespace)::OpaqueType<2u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata, unsigned int, 64, 64>, at::native::(anonymous namespace)::TensorSizeStride, int, unsigned int)", + "device_type": "DeviceType.CUDA", + "count": 384, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 1836.1510000003036, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 16, + 456, + 64 + ], + [ + 1, + 16, + 456, + 64 + ], + [] + ], + "cpu_us": 570.20999999989, + "gpu_us": 150.0119999999588, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 4, + 456, + 64 + ], + [ + 1, + 1, + 456, + 64 + ] + ], + "cpu_us": 935.1340000002965, + "gpu_us": 228.2549999999028, + "annotation": false + }, + { + "op": "aten::slice", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 4, + 456, + 64 + ], + [], + [], + [], + [] + ], + "cpu_us": 351.6090000009135, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 4, + 456, + 64 + ], + [], + [], + [] + ], + "cpu_us": 68.47599999977683, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::neg", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 4, + 456, + 32 + ] + ], + "cpu_us": 471.2929999987973, + "gpu_us": 107.29200000100536, + "annotation": false + }, + { + "op": "aten::add", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 4, + 456, + 64 + ], + [ + 1, + 4, + 456, + 64 + ], + [] + ], + "cpu_us": 462.24699999975564, + "gpu_us": 117.02600000009988, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 0 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 175.504999999539, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 0 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 487.37600000090606, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::lift_fresh", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 0 + ] + ], + "cpu_us": 35.379999999699066, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::detach_", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 0 + ] + ], + "cpu_us": 288.30499999919266, + "gpu_us": 0, + "annotation": false + }, + { + "op": "detach_", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 0 + ] + ], + "cpu_us": 112.88899999960267, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::scaled_dot_product_attention", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 16, + 456, + 256 + ], + [ + 1, + 4, + 456, + 256 + ], + [ + 1, + 4, + 456, + 256 + ], + [], + [], + [], + [], + [] + ], + "cpu_us": 902.0229999987496, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_scaled_dot_product_flash_attention", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 16, + 456, + 256 + ], + [ + 1, + 4, + 456, + 256 + ], + [ + 1, + 4, + 456, + 256 + ], + [], + [], + [], + [] + ], + "cpu_us": 936.3590000002587, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 16, + 456, + 256 + ], + [], + [] + ], + "cpu_us": 425.4400000009773, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 128, + "input_shapes": [ + [ + 1, + 4, + 456, + 256 + ], + [], + [] + ], + "cpu_us": 208.5709999997198, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::_flash_attention_forward", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [ + 1, + 456, + 4, + 256 + ], + [ + 1, + 456, + 4, + 256 + ], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 1603.2360000005283, + "gpu_us": 2598.8570000014297, + "annotation": false + }, + { + "op": "void pytorch_flash::flash_fwd_splitkv_kernel >, true, false, false, false, true, false, true, false>(pytorch_flash::Flash_fwd_params)", + "device_type": "DeviceType.CUDA", + "count": 64, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 2146.5690000004397, + "annotation": false + }, + { + "op": "aten::contiguous", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 16, + 256 + ], + [] + ], + "cpu_us": 148.444999999454, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "void pytorch_flash::flash_fwd_splitkv_combine_kernel >, 4, 1, true>(pytorch_flash::Flash_fwd_params)", + "device_type": "DeviceType.CUDA", + "count": 64, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 452.28800000099, + "annotation": false + }, + { + "op": "aten::sigmoid", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4096 + ] + ], + "cpu_us": 586.9170000011654, + "gpu_us": 211.6689999999653, + "annotation": false + }, + { + "op": "aten::mul", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 1, + 456, + 4096 + ] + ], + "cpu_us": 508.45299999951385, + "gpu_us": 223.68200000004435, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [], + [], + [], + [] + ], + "cpu_us": 103.7749999986554, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 251.95200000041223, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 1, + 456, + 4096 + ], + [] + ], + "cpu_us": 310.5599999998958, + "gpu_us": 431.9820000003965, + "annotation": false + }, + { + "op": "aten::dropout", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [], + [] + ], + "cpu_us": 21.191999999660766, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 16, + 4096 + ], + [] + ], + "cpu_us": 139.19099999986065, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 1, + 456, + 4096 + ], + [ + 4096, + 16 + ] + ], + "cpu_us": 296.92700000081095, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 64, + "input_shapes": [ + [ + 456, + 4096 + ], + [ + 4096, + 16 + ] + ], + "cpu_us": 1082.6240000008838, + "gpu_us": 609.3320000005624, + "annotation": false + }, + { + "op": "aten::alias", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 456, + 2560 + ] + ], + "cpu_us": 34.39700000011362, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::linear", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 248320, + 2560 + ], + [] + ], + "cpu_us": 19.308999999862863, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::t", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 248320, + 2560 + ] + ], + "cpu_us": 15.544999999954598, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::transpose", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 248320, + 2560 + ], + [], + [] + ], + "cpu_us": 15.332000000402331, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::matmul", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 456, + 2560 + ], + [ + 2560, + 248320 + ] + ], + "cpu_us": 41.44299999973737, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::mm", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 456, + 2560 + ], + [ + 2560, + 248320 + ] + ], + "cpu_us": 198.52200000037556, + "gpu_us": 35928.61800000031, + "annotation": false + }, + { + "op": "ampere_bf16_s16816gemm_bf16_128x64_ldg8_f2f_tn", + "device_type": "DeviceType.CUDA", + "count": 8, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 35928.61800000031, + "annotation": false + }, + { + "op": "aten::_unsafe_view", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 456, + 248320 + ], + [] + ], + "cpu_us": 7.19800000009127, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 456, + 248320 + ], + [], + [] + ], + "cpu_us": 42.087000000086846, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 1, + 456, + 248320 + ], + [], + [], + [] + ], + "cpu_us": 7.46999999997206, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::select", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 456, + 248320 + ], + [], + [] + ], + "cpu_us": 22.321999999170657, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 456, + 248320 + ], + [], + [], + [] + ], + "cpu_us": 5.702000000368571, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::_to_copy", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 3 + ], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 111.05700000026263, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::copy_", + "device_type": "DeviceType.CPU", + "count": 24, + "input_shapes": [ + [ + 3 + ], + [ + 3 + ], + [] + ], + "cpu_us": 140.35099999938393, + "gpu_us": 22.191000000340864, + "annotation": false + }, + { + "op": "aten::lift_fresh", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3 + ] + ], + "cpu_us": 2.2349999997240957, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::detach_", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3 + ] + ], + "cpu_us": 13.772999999899184, + "gpu_us": 0, + "annotation": false + }, + { + "op": "detach_", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3 + ] + ], + "cpu_us": 6.103000000119209, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::index", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 248320 + ], + [] + ], + "cpu_us": 185.78300000046147, + "gpu_us": 18.760000000009313, + "annotation": false + }, + { + "op": "aten::as_strided", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 248320 + ], + [], + [], + [] + ], + "cpu_us": 4.402999999729218, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::reshape", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3 + ], + [] + ], + "cpu_us": 9.986999999848194, + "gpu_us": 0, + "annotation": false + }, + { + "op": "void at::native::index_elementwise_kernel<128, 4, at::native::gpu_index_kernel >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_kernel_impl >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1}>(long, at::native::gpu_index_kernel >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef, at::native::index_kernel_impl >(at::TensorIteratorBase&, c10::ArrayRef, c10::ArrayRef)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1})", + "device_type": "DeviceType.CUDA", + "count": 8, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 18.760000000009313, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3 + ], + [], + [], + [], + [] + ], + "cpu_us": 12.986999999906402, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::softmax", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3 + ], + [], + [] + ], + "cpu_us": 26.64500000033877, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "aten::_softmax", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3 + ], + [], + [] + ], + "cpu_us": 97.74399999968591, + "gpu_us": 8.518000000010943, + "annotation": false + }, + { + "op": "void (anonymous namespace)::softmax_warp_forward(float*, float const*, int, int, int, bool const*, int, bool)", + "device_type": "DeviceType.CUDA", + "count": 8, + "input_shapes": [], + "cpu_us": 0, + "gpu_us": 8.518000000010943, + "annotation": false + }, + { + "op": "aten::resolve_conj", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3 + ] + ], + "cpu_us": 3.7400000000488944, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::resolve_neg", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3 + ] + ], + "cpu_us": 2.1350000000966247, + "gpu_us": 0, + "annotation": false + }, + { + "op": "aten::to", + "device_type": "DeviceType.CPU", + "count": 8, + "input_shapes": [ + [ + 3 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "cpu_us": 11.299999999901047, + "gpu_us": 0.0, + "annotation": false + }, + { + "op": "Buffer Flush", + "device_type": "DeviceType.CPU", + "count": 5, + "input_shapes": [], + "cpu_us": 484.454000000027, + "gpu_us": 0, + "annotation": false + }, + { + "op": "cudaDeviceSynchronize", + "device_type": "DeviceType.CPU", + "count": 2, + "input_shapes": [], + "cpu_us": 10.06899999990128, + "gpu_us": 0, + "annotation": false + } + ] +} \ No newline at end of file diff --git a/recipe/cua_s1/experiments/rtx4090-last-logits/verify_results.py b/recipe/cua_s1/experiments/rtx4090-last-logits/verify_results.py new file mode 100644 index 0000000..09ec43c --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-last-logits/verify_results.py @@ -0,0 +1,118 @@ +"""Independently audit every saved final-token projection sample.""" + +import json +import math +import statistics +from pathlib import Path + +ROOT = Path(__file__).resolve().parent +VARIANTS = ("full_projection", "last_token_projection") + + +def main(): + report = json.loads((ROOT / "paired.json").read_text()) + correctness = json.loads((ROOT / "correctness.json").read_text()) + postflight = json.loads((ROOT / "postflight.json").read_text()) + assert report["status"] == "complete" + assert report["repository"]["dirty"] is False + assert correctness["status"] == postflight["status"] == "complete" + for checked in (correctness, postflight): + assert checked["repository"]["revision"] == report["repository"]["revision"] + assert checked["repository"]["dirty"] is False + assert checked["environment"] == report["environment"] + assert postflight["health"]["status"] == postflight["http"]["status"] == 200 + assert postflight["http"]["exact_engine_parity"] + assert postflight["http"]["question_count"] == 8 + assert len(correctness["correctness"]) == 13 + assert ( + sum(len(case["response"]["answers"]) for case in correctness["correctness"]) + == 49 + ) + for case in correctness["correctness"]: + assert case["exact_prepared_tensor_parity"] + assert case["exact_language_input_parity"] + assert case["exact_response_parity"] + n = len(case["response"]["answers"]) + assert case["baseline_counts"] == { + "image_preprocess": n, + "vision": n, + "language": n, + } + assert case["reuse_counts"] == { + "image_preprocess": 1, + "vision": 1, + "language": n, + } + assert report["config"]["case"] == [] + assert (report["config"]["runs"], report["config"]["iterations"]) == (2, 30) + expected = { + f"{size}-{goal}-q{questions}" + for size in ("320x240", "640x480") + for goal in ("short", "long") + for questions in (1, 2, 4, 8) + } | {"640x480-distinct-q8"} + cases = report["cases"] + assert len(cases) == 17 + assert {case["id"] for case in cases} == expected + total = 0 + print( + "| Case | Full p50 ms | Last p50 ms | p50 reduction | Full p95 ms | Last p95 ms | Peak allocated GiB, full → last |" + ) + print("| --- | ---: | ---: | ---: | ---: | ---: | ---: |") + for case in sorted(cases, key=lambda value: value["id"]): + assert case["status"] == "complete" and case["exact_response_parity"] + n = case["questions"] + assert len(case["full_head_shapes"]) == len(case["last_head_shapes"]) == n + for full, last in zip(case["full_head_shapes"], case["last_head_shapes"]): + assert len(full) == len(last) == 3 + assert full[0] == last[0] == 1 and full[2] == last[2] == 2560 + assert full[1] > 1 + assert last[1] == (full[1] if n == 1 else 1) + assert len(case["runs"]) == 2 + for run_index, run in enumerate(case["runs"]): + assert run["run"] == run_index + 1 + assert len(run["orders"]) == 30 + for iteration, order in enumerate(run["orders"]): + selected = list(VARIANTS) + if (run_index + iteration) % 2: + selected.reverse() + assert order == selected + for name in VARIANTS: + values = run[name]["latencies_ms"] + assert len(values) == 30 + assert all(math.isfinite(value) and value > 0 for value in values) + assert statistics.median(values) == run[name]["p50_ms"] + assert ( + sorted(values)[math.ceil(0.95 * len(values)) - 1] + == run[name]["p95_ms"] + ) + assert ( + run[name]["peak_reserved_bytes"] + >= run[name]["peak_allocated_bytes"] + > 0 + ) + total += len(values) + + def times(name, metric, case=case): + return " / ".join(f"{run[name][metric]:.2f}" for run in case["runs"]) + + reduction = " / ".join( + f"{100 * (1 - run['last_token_projection']['p50_ms'] / run['full_projection']['p50_ms']):.1f}%" + for run in case["runs"] + ) + memory = " → ".join( + f"{max(run[name]['peak_allocated_bytes'] for run in case['runs']) / 2**30:.3f}" + for name in VARIANTS + ) + print( + f"| {case['id']} | {times('full_projection', 'p50_ms')} | " + f"{times('last_token_projection', 'p50_ms')} | {reduction} | " + f"{times('full_projection', 'p95_ms')} | " + f"{times('last_token_projection', 'p95_ms')} | {memory} |" + ) + assert total == 2040 + print(f"Verified {len(cases)} cases and {total} timed predictions.") + + +if __name__ == "__main__": + main() From c522e00a79a67343a9a1b72a28243f794c576b8f Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 14:43:22 +0800 Subject: [PATCH 20/26] docs(cua-s1): record experiment publication and server shutdown --- .../plans/2026-09-28-cua-post-reuse-optimization.md | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/docs/superpowers/plans/2026-09-28-cua-post-reuse-optimization.md b/docs/superpowers/plans/2026-09-28-cua-post-reuse-optimization.md index 261e072..1a9742e 100644 --- a/docs/superpowers/plans/2026-09-28-cua-post-reuse-optimization.md +++ b/docs/superpowers/plans/2026-09-28-cua-post-reuse-optimization.md @@ -16,5 +16,9 @@ - [x] Modify `score_reused` in `src/models/cua_s1/multimodal/model.py` and clean up a nearby Ruff guard; rerun the focused test and the full Cua-S1 suite. - [x] Add a paired benchmark recipe with explicit baseline selection, alternating order, raw samples, response parity, source and environment metadata, and peak allocated memory. - [x] Commit a clean source revision, transfer it to the GPU host, and run correctness and timed measurements. Review raw samples, variability, kernel changes, and single-question behavior. -- [ ] Publish result data and reproduction commands, run verification, push the branch, create and attach the PR. -- [ ] Archive and checksum complete GPU evidence locally, ensure no experiment is running, shut down the server, and verify it no longer accepts SSH. +- [x] Publish result data and reproduction commands, run verification, push the branch, create and attach the PR. +- [x] Archive and checksum complete GPU evidence locally, ensure no experiment is running, shut down the server, and verify it no longer accepts SSH. + +## Completion evidence + +Published [PR #18](https://github.com/ThinkFlowLab/system1-omni/pull/18) with the 17-case, 2,040-prediction dataset. The independent audit recomputed every saved p50/p95 and passed the 13-fixture, 49-question exact correctness and eight-question HTTP checks. Clean measured source `224d88b` passed 105 Cua-S1 tests on the GPU host; local tests passed 104 with one torch-dependent skip. The full trace archive SHA-256 matched on the server and local host: `774d952e89a9586709419c6c8583e4aa7ee2d27b4bf836253c8c01881c4dccd9`. The platform shutdown command exited successfully, and a subsequent SSH attempt was refused. From a2abe7e7fc776d6fb6c095f8b951c5e10698795f Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 15:15:22 +0800 Subject: [PATCH 21/26] bench(cua-s1): measure multimodal CUDA Graph language forward --- recipe/cua_s1/benchmark_multimodal_graph.py | 383 ++++++++++++++++++ .../cua_s1/test_multimodal_graph_benchmark.py | 64 +++ 2 files changed, 447 insertions(+) create mode 100644 recipe/cua_s1/benchmark_multimodal_graph.py create mode 100644 tests/cua_s1/test_multimodal_graph_benchmark.py diff --git a/recipe/cua_s1/benchmark_multimodal_graph.py b/recipe/cua_s1/benchmark_multimodal_graph.py new file mode 100644 index 0000000..7f9d548 --- /dev/null +++ b/recipe/cua_s1/benchmark_multimodal_graph.py @@ -0,0 +1,383 @@ +"""Compare eager and CUDA Graph language forwards on the reused multimodal path.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import statistics +import time +from dataclasses import replace +from pathlib import Path + +from benchmark_image_reuse import distinct_fixture +from profile_multimodal import case_matrix, fixture, repository_state, write_json + + +def language_inputs(engine, inputs, features): + """Prepare per-question tensors exactly as the production reuse path does.""" + core = engine.model.get_base_model().model + text = { + key: value.to(engine.model.device) + for key, value in inputs.items() + if key != "pixel_values" + } + ids = text.pop("input_ids") + embeds = core.get_input_embeddings()(ids) + image_embeds = features.to(embeds.device, embeds.dtype) + mask, _ = core.get_placeholder_mask( + ids, inputs_embeds=embeds, image_features=image_embeds + ) + embeds = embeds.masked_scatter(mask, image_embeds) + positions, _ = core.get_rope_index( + input_ids=ids, + mm_token_type_ids=text.pop("mm_token_type_ids"), + image_grid_thw=text.pop("image_grid_thw"), + attention_mask=text.get("attention_mask"), + ) + return { + "inputs_embeds": embeds, + "position_ids": positions, + "attention_mask": text["attention_mask"], + } + + +class GraphForward: + """One exact-shape graph; static buffers remain alive for every replay.""" + + def __init__(self, model, example): + import torch + + self.model = model + self.buffers = {name: value.clone() for name, value in example.items()} + self.signatures = { + name: tensor_signature(value) for name, value in example.items() + } + self.capture_ms = 0.0 + torch.cuda.synchronize() + start = time.perf_counter() + allocated_before = torch.cuda.memory_allocated() + reserved_before = torch.cuda.memory_reserved() + stream = torch.cuda.Stream() + stream.wait_stream(torch.cuda.current_stream()) + with torch.cuda.stream(stream), torch.no_grad(): + for _ in range(3): + self._forward() + torch.cuda.current_stream().wait_stream(stream) + torch.cuda.synchronize() + self.graph = torch.cuda.CUDAGraph() + with torch.cuda.graph(self.graph), torch.no_grad(): + self.static_logits = self._forward() + torch.cuda.synchronize() + self.capture_ms = (time.perf_counter() - start) * 1000 + self.capture_allocated_delta_bytes = ( + torch.cuda.memory_allocated() - allocated_before + ) + self.capture_reserved_delta_bytes = ( + torch.cuda.memory_reserved() - reserved_before + ) + + def _forward(self): + return self.model(**self.buffers, logits_to_keep=1, use_cache=False).logits[ + 0, -1, : + ] + + def forward(self, values): + for name, value in values.items(): + if tensor_signature(value) != self.signatures[name]: + raise ValueError(f"graph tensor layout changed for {name}") + self.buffers[name].copy_(value) + self.graph.replay() + return self.static_logits + + +def tensor_signature(value): + return ( + tuple(value.shape), + tuple(value.stride()), + str(value.dtype), + str(value.device), + ) + + +class Scorer: + def __init__(self, engine, graph=False): + self.engine = engine + self.graph = graph + self.runners = {} + self.capture_ms = [] + + def score(self, inputs, question, features): + import torch + + from models.cua_s1.multimodal.model import letter_ids + + with torch.no_grad(): + values = language_inputs(self.engine, inputs, features) + if self.graph: + key = tuple( + (name, tensor_signature(value)) for name, value in values.items() + ) + if key not in self.runners: + self.runners[key] = GraphForward(self.engine.model, values) + self.capture_ms.append(self.runners[key].capture_ms) + logits = self.runners[key].forward(values) + else: + logits = self.engine.model( + **values, logits_to_keep=1, use_cache=False + ).logits[0, -1, :] + ids = letter_ids(self.engine.tokenizer, len(question.keys)) + return torch.softmax( + logits[torch.tensor(ids, device=logits.device)].float(), dim=-1 + ).tolist() + + +def run_variant(engine, scorer, request): + original = engine.score_reused + engine.score_reused = scorer.score + try: + return engine.predict(request) + finally: + engine.score_reused = original + + +def measure(call): + import torch + + torch.cuda.synchronize() + start = time.perf_counter() + value = call() + torch.cuda.synchronize() + return value, (time.perf_counter() - start) * 1000 + + +def summarize(values): + ordered = sorted(values) + return { + "samples_ms": values, + "p50_ms": statistics.median(values), + "p95_ms": ordered[min(len(ordered) - 1, int(len(ordered) * 0.95))], + } + + +def response_difference(expected, actual): + if expected["model"] != actual["model"] or expected["usage"] != actual["usage"]: + raise ValueError("model identity or usage changed") + if expected["answers"].keys() != actual["answers"].keys(): + raise ValueError("answer keys changed") + worst = 0.0 + for name, before in expected["answers"].items(): + after = actual["answers"][name] + if before["type"] != after["type"] or before["choice"] != after["choice"]: + raise ValueError(f"{name}: selected choice changed") + if before["probabilities"].keys() != after["probabilities"].keys(): + raise ValueError(f"{name}: candidate keys changed") + worst = max( + worst, + *( + abs(value - after["probabilities"][key]) + for key, value in before["probabilities"].items() + ), + ) + return worst + + +def main(argv=None): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--weights", required=True, type=Path) + parser.add_argument("--output", required=True, type=Path) + parser.add_argument("--case", action="append", default=[]) + parser.add_argument("--warmup", type=int, default=3) + parser.add_argument("--runs", type=int, default=2) + parser.add_argument("--iterations", type=int, default=20) + args = parser.parse_args(argv) + known = {case["id"] for case in case_matrix()} | {"640x480-distinct-q8"} + if len(args.case) != len(set(args.case)) or set(args.case) - known: + parser.error("duplicate or unknown case") + if not args.case: + parser.error("select at least one --case for this bounded experiment") + if min(args.warmup, args.runs, args.iterations) <= 0: + parser.error("warmup, runs and iterations must be positive") + if (args.output / "report.json").exists(): + parser.error("report already exists; use a fresh output directory") + + import torch + from evaluate_multimodal import environment + + from models.cua_s1.multimodal.model import MultimodalEngine + from models.cua_s1.multimodal.protocol import parse_request + + args.output.mkdir(parents=True, exist_ok=True) + report_path = args.output / "report.json" + report = { + "status": "running", + "repository": repository_state(Path(__file__).resolve().parents[2]), + "environment": environment(), + "config": { + "warmup": args.warmup, + "runs": args.runs, + "iterations": args.iterations, + "cases": args.case, + "scope": "synchronized engine.predict; Graph captures model forward after vision, text embeddings and 3D positions; both variants use_cache=False", + }, + "cases": [], + } + write_json(report_path, report) + try: + engine = MultimodalEngine( + str(args.weights / "Qwen3.5-4B"), + str(args.weights / "cua-s1-4b-0.2/multimodal"), + ) + selected = case_matrix() + [{"id": "640x480-distinct-q8"}] + selected = [case for case in selected if case["id"] in args.case] + for case in selected: + value = ( + distinct_fixture(args.output / "fixtures") + if case["id"] == "640x480-distinct-q8" + else fixture(case, args.output / "fixtures") + ) + request = parse_request(value) + item = {"id": case["id"], "status": "running", "runs": []} + report["cases"].append(item) + write_json(report_path, report) + if len(request.questions) == 1: + item["status"] = "skipped_single_question" + write_json(report_path, report) + continue + eager, graph = Scorer(engine), Scorer(engine, graph=True) + baseline = engine.predict(request) + eager_response = run_variant(engine, eager, request) + graph_response = run_variant(engine, graph, request) + if baseline != eager_response: + item["parity_diagnostic"] = { + "baseline": baseline, + "eager": eager_response, + "graph": graph_response, + } + write_json(report_path, report) + raise ValueError(f"{case['id']}: eager response differs") + item["max_graph_probability_difference"] = response_difference( + baseline, graph_response + ) + if item["max_graph_probability_difference"] > 0.002: + item["parity_diagnostic"] = { + "baseline": baseline, + "graph": graph_response, + "graph_shapes": [list(key) for key in graph.runners], + } + item["status"] = "rejected_graph" + write_json(report_path, report) + raise ValueError( + f"{case['id']}: graph probability difference exceeds 0.002" + ) + item["exact_eager_response_parity"] = True + # Replay the same graph after a substantial image change, then return + # to the original input. This detects stale captured input pointers. + from PIL import Image + + changed = replace( + request, image=Image.new("RGB", request.image.size, "black") + ) + changed_eager = run_variant(engine, eager, changed) + graphs_before = len(graph.runners) + changed_graph = run_variant(engine, graph, changed) + original_again = run_variant(engine, graph, request) + if len(graph.runners) != graphs_before: + raise ValueError( + f"{case['id']}: image change unexpectedly changed graph shapes" + ) + item["changed_image_max_probability_difference"] = response_difference( + changed_eager, changed_graph + ) + if item["changed_image_max_probability_difference"] > 0.002: + raise ValueError(f"{case['id']}: changed-image graph response differs") + if response_difference(baseline, original_again) > 0.002: + raise ValueError(f"{case['id']}: original input was not restored") + if changed_eager == baseline: + raise ValueError( + f"{case['id']}: changed image did not change eager response" + ) + item["changed_image_replay_checked"] = True + item["fixture_sha256"] = hashlib.sha256( + json.dumps(value, sort_keys=True).encode() + ).hexdigest() + item["capture_ms"] = graph.capture_ms + item["graph_count"] = len(graph.runners) + item["capture_allocated_delta_bytes"] = [ + runner.capture_allocated_delta_bytes + for runner in graph.runners.values() + ] + item["capture_reserved_delta_bytes"] = [ + runner.capture_reserved_delta_bytes for runner in graph.runners.values() + ] + for _ in range(args.warmup): + run_variant(engine, eager, request) + run_variant(engine, graph, request) + for run in range(args.runs): + samples = {"eager": [], "graph": []} + orders = [] + peaks = {"eager": 0, "graph": 0} + for iteration in range(args.iterations): + order = ["eager", "graph"] + if (run + iteration) % 2: + order.reverse() + orders.append(order) + for name in order: + scorer = eager if name == "eager" else graph + torch.cuda.reset_peak_memory_stats() + response, elapsed = measure( + lambda scorer=scorer, request=request: run_variant( + engine, scorer, request + ) + ) + if name == "eager" and response != baseline: + raise ValueError( + f"{case['id']}: timed eager response differs" + ) + if ( + name == "graph" + and response_difference(baseline, response) > 0.002 + ): + raise ValueError( + f"{case['id']}: timed graph response differs" + ) + samples[name].append(elapsed) + peaks[name] = max( + peaks[name], torch.cuda.max_memory_allocated() + ) + item["runs"].append( + { + "orders": orders, + **{ + name: { + **summarize(values), + "peak_allocated_bytes": peaks[name], + } + for name, values in samples.items() + }, + } + ) + write_json(report_path, report) + item["status"] = "complete" + del graph + torch.cuda.empty_cache() + write_json(report_path, report) + print( + case["id"], + [ + (round(x["eager"]["p50_ms"], 2), round(x["graph"]["p50_ms"], 2)) + for x in item["runs"] + ], + flush=True, + ) + report["status"] = "complete" + except Exception as exc: + report["status"] = "failed" + report["error"] = {"type": type(exc).__name__, "message": str(exc)} + raise + finally: + write_json(report_path, report) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tests/cua_s1/test_multimodal_graph_benchmark.py b/tests/cua_s1/test_multimodal_graph_benchmark.py new file mode 100644 index 0000000..3b47da1 --- /dev/null +++ b/tests/cua_s1/test_multimodal_graph_benchmark.py @@ -0,0 +1,64 @@ +"""Guard the graph experiment's response comparison against changed choices.""" + +import importlib.util +from copy import deepcopy +from pathlib import Path +from types import SimpleNamespace + +import pytest + + +@pytest.fixture +def graph_benchmark(monkeypatch): + recipe = Path(__file__).resolve().parents[2] / "recipe/cua_s1" + monkeypatch.syspath_prepend(str(recipe)) + spec = importlib.util.spec_from_file_location( + "benchmark_multimodal_graph", recipe / "benchmark_multimodal_graph.py" + ) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def response(): + return { + "model": "pinned", + "usage": {"input_tokens": 3, "output_tokens": 0}, + "answers": { + "next": { + "type": "choice", + "choice": "save", + "probabilities": {"save": 0.8, "cancel": 0.2}, + } + }, + } + + +def test_graph_comparison_tracks_probability_difference(graph_benchmark): + actual = deepcopy(response()) + actual["answers"]["next"]["probabilities"]["save"] = 0.799 + assert graph_benchmark.response_difference(response(), actual) == pytest.approx( + 0.001 + ) + + +def test_graph_comparison_rejects_changed_choice(graph_benchmark): + actual = deepcopy(response()) + actual["answers"]["next"]["choice"] = "cancel" + with pytest.raises(ValueError, match="selected choice changed"): + graph_benchmark.response_difference(response(), actual) + + +def test_graph_signature_includes_layout_and_dtype(graph_benchmark): + value = SimpleNamespace( + shape=(1, 4, 8), + stride=lambda: (32, 8, 1), + dtype="bfloat16", + device="cuda:0", + ) + assert graph_benchmark.tensor_signature(value) == ( + (1, 4, 8), + (32, 8, 1), + "bfloat16", + "cuda:0", + ) From 809cacc70979b1b4e3a55b8b89be4691d09b0ce4 Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 15:23:18 +0800 Subject: [PATCH 22/26] bench(cua-s1): validate graph replay with changed question text --- recipe/cua_s1/benchmark_multimodal_graph.py | 48 +++++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/recipe/cua_s1/benchmark_multimodal_graph.py b/recipe/cua_s1/benchmark_multimodal_graph.py index 7f9d548..67e3b87 100644 --- a/recipe/cua_s1/benchmark_multimodal_graph.py +++ b/recipe/cua_s1/benchmark_multimodal_graph.py @@ -182,6 +182,28 @@ def response_difference(expected, actual): return worst +def changed_text_request(engine, request): + """Find different words that retain every prepared question's tensor shape.""" + import torch + + before = engine.prepare_reused(request.image, request.questions) + for verb in ("Open", "Close", "View", "Read", "Edit", "Keep"): + questions = tuple( + replace(question, goal=question.goal.replace("Save", verb)) + for question in request.questions + ) + if questions == request.questions: + continue + after = engine.prepare_reused(request.image, questions) + if all( + old["input_ids"].shape == new["input_ids"].shape + and not torch.equal(old["input_ids"], new["input_ids"]) + for old, new in zip(before, after) + ): + return replace(request, questions=questions), verb + raise ValueError("no same-shape changed-text fixture available") + + def main(argv=None): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--weights", required=True, type=Path) @@ -298,6 +320,32 @@ def main(argv=None): f"{case['id']}: changed image did not change eager response" ) item["changed_image_replay_checked"] = True + changed_text, verb = changed_text_request(engine, request) + text_eager = run_variant(engine, eager, changed_text) + graphs_before = len(graph.runners) + text_graph = run_variant(engine, graph, changed_text) + original_again = run_variant(engine, graph, request) + if len(graph.runners) != graphs_before: + raise ValueError( + f"{case['id']}: text change unexpectedly changed graph shapes" + ) + item["changed_text_verb"] = verb + item["changed_text_max_probability_difference"] = response_difference( + text_eager, text_graph + ) + if item["changed_text_max_probability_difference"] > 0.002: + item["status"] = "rejected_graph" + write_json(report_path, report) + raise ValueError(f"{case['id']}: changed-text graph response differs") + if response_difference(baseline, original_again) > 0.002: + raise ValueError( + f"{case['id']}: original input was not restored after text change" + ) + if text_eager == baseline: + raise ValueError( + f"{case['id']}: changed text did not change eager response" + ) + item["changed_text_replay_checked"] = True item["fixture_sha256"] = hashlib.sha256( json.dumps(value, sort_keys=True).encode() ).hexdigest() From 74b8c9e80005b4531b6dce7d5ae93934b3b0d583 Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Mon, 28 Sep 2026 15:31:14 +0800 Subject: [PATCH 23/26] docs(cua-s1): publish multimodal CUDA Graph evidence --- recipe/cua_s1/experiments/README.md | 4 + .../experiments/rtx4090-graph/README.md | 97 ++ .../experiments/rtx4090-graph/SHA256SUMS | 4 + .../rtx4090-graph/distinct-rejected.json | 631 ++++++++++++ .../rtx4090-graph/long-rejected.json | 61 ++ .../experiments/rtx4090-graph/paired.json | 948 ++++++++++++++++++ .../rtx4090-graph/verify_results.py | 70 ++ 7 files changed, 1815 insertions(+) create mode 100644 recipe/cua_s1/experiments/rtx4090-graph/README.md create mode 100644 recipe/cua_s1/experiments/rtx4090-graph/SHA256SUMS create mode 100644 recipe/cua_s1/experiments/rtx4090-graph/distinct-rejected.json create mode 100644 recipe/cua_s1/experiments/rtx4090-graph/long-rejected.json create mode 100644 recipe/cua_s1/experiments/rtx4090-graph/paired.json create mode 100644 recipe/cua_s1/experiments/rtx4090-graph/verify_results.py diff --git a/recipe/cua_s1/experiments/README.md b/recipe/cua_s1/experiments/README.md index ae1e0ef..d3ed0f6 100644 --- a/recipe/cua_s1/experiments/README.md +++ b/recipe/cua_s1/experiments/README.md @@ -1,5 +1,9 @@ # RTX 4090 multimodal validation — 2026-09-27 +For the later bounded CUDA Graph experiment after image reuse and last-token +projection, see the [Graph feasibility report](rtx4090-graph/README.md). It +includes both successful fixed-shape cases and correctness-gated rejections. + For the subsequent 16-case stage profiling experiment, refreshed upstream parity, and profiler annotation-counting recovery, see the [2026-09-28 report](rtx4090-profile/README.md). The measurements below remain the diff --git a/recipe/cua_s1/experiments/rtx4090-graph/README.md b/recipe/cua_s1/experiments/rtx4090-graph/README.md new file mode 100644 index 0000000..eb161da --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-graph/README.md @@ -0,0 +1,97 @@ +# Cua-S1 multimodal CUDA Graph feasibility — RTX 4090, 2026-09-28 + +CUDA Graph replay of the language forward reduces synchronized `engine.predict` +latency for these **fixed-shape, short-instruction** requests. This is an +experiment on the Transformers/PEFT multimodal worker after the image reuse and +last-token projection changes in #17 and #18. It does not add a production Graph +path or make a claim about the separate native text worker in #19. + +The graph captures `model(inputs_embeds, position_ids, attention_mask, +logits_to_keep=1, use_cache=False)` after image encoding, text embedding, image +insertion, and three-dimensional position construction. Both measured variants +use `use_cache=False`; the eager variant returns exactly the original worker +response. Graph replay copies the current tensors into long-lived buffers whose +shape, stride, dtype, and device match capture. A graph is keyed by that tensor +layout. Image processing, image encoding, prompt preparation, candidate scoring, +and response assembly run normally on every request. + +## Result and correctness boundary + +The table gives p50 milliseconds from two alternating runs of 20 calls per +variant and case (240 timed predictions total). Each case used three warmup calls +per variant. Timings synchronize CUDA around each whole `engine.predict`; they +exclude request parsing, fixture creation, model load, graph capture, HTTP, and +concurrent traffic. Percentages compare Graph to eager within the same run. + +| Synthetic case | Eager p50, runs 1 / 2 | Graph p50, runs 1 / 2 | Reduction, runs 1 / 2 | First capture with 3 warmups | +| --- | ---: | ---: | ---: | ---: | +| 320×240, short instruction, 2 repeated questions | 181.42 / 183.28 | 100.31 / 100.38 | 44.7% / 45.2% | 355 ms | +| 320×240, short instruction, 8 repeated questions | 669.81 / 684.26 | 337.57 / 338.21 | 49.6% / 50.6% | 347 ms | +| 640×480, short instruction, 8 repeated questions | 825.78 / 786.77 | 562.90 / 561.72 | 31.8% / 28.6% | 416 ms | + +For all three rows, eager produced the original response exactly. Graph retained +the selected choices, model identity, usage, and answer keys. The largest +candidate probability difference from the original response was 0.000421; +the experiment's absolute probability threshold was 0.002. Replaying after +replacing the image with a same-size black image, then returning to the original, +passed with at most 0.000781 probability difference. Replacing “Save” with a +different same-token-length verb, then returning to the original, also passed. +The saved reports include these checks for each case. The post-capture +`torch.cuda.memory_allocated()` increase was 9–17 MiB for one graph. This +allocator measure is not a total GPU-card memory measurement. + +Two additional cases **failed the correctness gate** and were not timed as +supported Graph paths: + +| Case | Observed failure | +| --- | --- | +| 640×480, 8 distinct questions | Seven graph layouts were captured. Candidate probability difference reached **0.065181** on the original input, despite the same chosen options. | +| 640×480, long instruction, 8 repeated questions | The original input and changed image were within 0.002, but a same-length changed question produced **0.051902** maximum probability difference. | + +Those deviations exceed the 0.002 experimental gate. The first appears during +the original distinct-question inference; the second appears only after changing +text. The cause is not yet isolated. This evidence supports a bounded +fixed-shape study and argues for tracing the captured language kernels before +adding Graph replay to a production worker. It does not establish correctness +for arbitrary questions, prompt lengths, GPUs, concurrent requests, or the +native engine. In particular, the fixed-input long-instruction speedup observed +during exploratory timing is not counted as usable. + +## Provenance and reproduction + +- Clean measured source: `809cacc70979b1b4e3a55b8b89be4691d09b0ce4`, on + the #18 stack. All three reports record this revision with `dirty: false`. +- One NVIDIA GeForce RTX 4090 (24,564 MiB, sm_89), driver 595.71.05, CUDA + runtime 13.0, Python 3.12.13, PyTorch 2.14.0, Transformers 5.17.0, PEFT + 0.21.0. Pinned BF16 base and unmerged multimodal LoRA were used. The + `causal_conv1d` and `flash-linear-attention` optional packages were absent, + so Transformers used its reference fallback kernels, as in #18. +- [paired.json](paired.json) contains every elapsed sample, run order, p50/p95, + capture cost, allocator measures, and correctness checks. The two rejected + reports, [distinct-rejected.json](distinct-rejected.json) and + [long-rejected.json](long-rejected.json), preserve the numerical failures. + [verify_results.py](verify_results.py) independently recomputes all 240 + samples and checks both rejections. +- The Cua-S1 test suite passed **108 tests** on this GPU host. Ruff lint and + formatting checks passed. [SHA256SUMS](SHA256SUMS) identifies the published + report files. +- A complete 186,201-byte evidence archive with fixtures, error logs, package + versions, and a Git source bundle was copied off the GPU host and verified + against server SHA-256 + `11831981ae8ea1c414075d563284b40b378a3471a8164c26b9a281986a12bee0`. + +Run from the measured source with the pinned weights and environment: + +```sh +PYTHONPATH=src:recipe/cua_s1 python recipe/cua_s1/benchmark_multimodal_graph.py \ + --weights /path/to/weights --output /path/to/new-output \ + --case 320x240-short-q2 --case 320x240-short-q8 \ + --case 640x480-short-q8 --warmup 3 --runs 2 --iterations 20 +python recipe/cua_s1/experiments/rtx4090-graph/verify_results.py +``` + +To reproduce a rejection, run the same command with only +`--case 640x480-distinct-q8` or `--case 640x480-long-q8`, and use a fresh output +directory. Both intentionally exit nonzero after saving `report.json`. The +verification script reads the committed report files; copy fresh reports to a +separate copy of this directory to audit a new run. diff --git a/recipe/cua_s1/experiments/rtx4090-graph/SHA256SUMS b/recipe/cua_s1/experiments/rtx4090-graph/SHA256SUMS new file mode 100644 index 0000000..4ae3174 --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-graph/SHA256SUMS @@ -0,0 +1,4 @@ +b511dff19890233ecfb2e516ad00e992d01475aaf1805a7e5a901ce90304d487 paired.json +63375b26136a1200f7df7d9504e5386323807fa66f974b87ffc390ed33533c78 distinct-rejected.json +5f4efc03af87bcd5eb1e6f57f0d523f6597c40a9bd713761ee7758b7985ba28f long-rejected.json +758053d2103a264792fe2ded0e5eb6519f76e392961aa5639d94887d47abb2ea verify_results.py diff --git a/recipe/cua_s1/experiments/rtx4090-graph/distinct-rejected.json b/recipe/cua_s1/experiments/rtx4090-graph/distinct-rejected.json new file mode 100644 index 0000000..2763aea --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-graph/distinct-rejected.json @@ -0,0 +1,631 @@ +{ + "status": "failed", + "repository": { + "revision": "809cacc70979b1b4e3a55b8b89be4691d09b0ce4", + "dirty": false, + "diff_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "untracked_files": [] + }, + "environment": { + "python": "3.12.13", + "gpu": "NVIDIA GeForce RTX 4090", + "compute_capability": [ + 8, + 9 + ], + "cuda": "13.0", + "driver": "595.71.05", + "torch_num_threads": 64, + "torch_num_interop_threads": 64, + "packages": { + "torch": "2.14.0", + "torchvision": "0.29.0", + "transformers": "5.17.0", + "peft": "0.21.0", + "pillow": "11.3.0", + "safetensors": "0.8.0", + "triton": "3.8.0" + }, + "reference_revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f", + "base_revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", + "adapter_revision": "16818868b0cc7813808aae4e87b417657046ab79", + "dtype": "bfloat16", + "adapter_merged": false + }, + "config": { + "warmup": 1, + "runs": 1, + "iterations": 2, + "cases": [ + "640x480-distinct-q8" + ], + "scope": "synchronized engine.predict; Graph captures model forward after vision, text embeddings and 3D positions; both variants use_cache=False" + }, + "cases": [ + { + "id": "640x480-distinct-q8", + "status": "rejected_graph", + "runs": [], + "max_graph_probability_difference": 0.06518101692199707, + "parity_diagnostic": { + "baseline": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.998498797416687, + "cancel": 0.0015011822106316686 + }, + "confidence": 0.9837552323853659 + }, + "q2": { + "type": "choice", + "choice": "cancel", + "probabilities": { + "cancel": 0.9995121955871582, + "save": 0.00048785717808641493 + }, + "confidence": 0.9939293781678539 + }, + "q3": { + "type": "choice", + "choice": "only", + "probabilities": { + "only": 1.0 + }, + "confidence": 1.0 + }, + "q4": { + "type": "choice", + "choice": "option-3", + "probabilities": { + "option-0": 0.07546718418598175, + "option-1": 0.00034948240499943495, + "option-2": 0.263406366109848, + "option-3": 0.557631254196167, + "option-4": 0.009013270027935505, + "option-5": 0.01908109337091446, + "option-6": 0.007019542157649994, + "option-7": 0.016839005053043365, + "option-8": 0.009013270027935505, + "option-9": 0.0025823453906923532, + "option-10": 0.004824455827474594, + "option-11": 0.003315796609967947, + "option-12": 0.002011132426559925, + "option-13": 0.0022789116483181715, + "option-14": 0.00619472423568368, + "option-15": 0.0010764816543087363, + "option-16": 0.0037572900764644146, + "option-17": 0.0006529190577566624, + "option-18": 0.002011132426559925, + "option-19": 0.0012198134791105986, + "option-20": 0.00044874430750496686, + "option-21": 0.0005084939184598625, + "option-22": 0.003315796609967947, + "option-23": 0.0013822298496961594, + "option-24": 0.0017748181708157063, + "option-25": 0.004824455827474594 + }, + "confidence": 0.5755459268738158 + }, + "q5": { + "type": "choice", + "choice": "object", + "probabilities": { + "null": 0.07443060725927353, + "object": 0.9067503809928894, + "array": 0.01881900243461132 + }, + "confidence": 0.6751463333759231 + }, + "q6": { + "type": "choice", + "choice": "first", + "probabilities": { + "first": 0.531209409236908, + "second": 0.4687906503677368 + }, + "confidence": 0.002812297157495758 + }, + "q7": { + "type": "choice", + "choice": "yes", + "probabilities": { + "yes": 0.9823379516601562, + "no": 0.0035428637638688087, + "wait": 0.006618940737098455, + "help": 0.007500242441892624 + }, + "confidence": 0.9225223144825633 + }, + "q8": { + "type": "choice", + "choice": "leave", + "probabilities": { + "stay": 0.01798621006309986, + "leave": 0.9820137619972229 + }, + "confidence": 0.8700206851739604 + } + }, + "usage": { + "input_tokens": 3874, + "output_tokens": 0 + } + }, + "graph": { + "model": "cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal", + "answers": { + "q1": { + "type": "choice", + "choice": "save", + "probabilities": { + "save": 0.9982993006706238, + "cancel": 0.001700722612440586 + }, + "confidence": 0.9819024674061465 + }, + "q2": { + "type": "choice", + "choice": "cancel", + "probabilities": { + "cancel": 0.9994471669197083, + "save": 0.000552778597921133 + }, + "confidence": 0.9932210278800853 + }, + "q3": { + "type": "choice", + "choice": "only", + "probabilities": { + "only": 1.0 + }, + "confidence": 1.0 + }, + "q4": { + "type": "choice", + "choice": "option-3", + "probabilities": { + "option-0": 0.07438431680202484, + "option-1": 0.00034446772770024836, + "option-2": 0.20219753682613373, + "option-3": 0.6228122711181641, + "option-4": 0.008883939124643803, + "option-5": 0.01880730129778385, + "option-6": 0.00691881962120533, + "option-7": 0.016597384586930275, + "option-8": 0.0078400494530797, + "option-9": 0.0025452913250774145, + "option-10": 0.004196476191282272, + "option-11": 0.003268218832090497, + "option-12": 0.001982274930924177, + "option-13": 0.0022462117485702038, + "option-14": 0.006105836946517229, + "option-15": 0.0012023105518892407, + "option-16": 0.004196476191282272, + "option-17": 0.000643550418317318, + "option-18": 0.001982274930924177, + "option-19": 0.0012023105518892407, + "option-20": 0.0003903330652974546, + "option-21": 0.0005011975881643593, + "option-22": 0.0028841933235526085, + "option-23": 0.0013623962877318263, + "option-24": 0.0017493516206741333, + "option-25": 0.004755230154842138 + }, + "confidence": 0.5976738836429945 + }, + "q5": { + "type": "choice", + "choice": "object", + "probabilities": { + "null": 0.08307360112667084, + "object": 0.8931254148483276, + "array": 0.023800985887646675 + }, + "confidence": 0.6389930733616893 + }, + "q6": { + "type": "choice", + "choice": "first", + "probabilities": { + "first": 0.5, + "second": 0.5 + }, + "confidence": 0.0 + }, + "q7": { + "type": "choice", + "choice": "yes", + "probabilities": { + "yes": 0.9831026196479797, + "no": 0.003545621642842889, + "wait": 0.005845741368830204, + "help": 0.007506080437451601 + }, + "confidence": 0.9253135095219104 + }, + "q8": { + "type": "choice", + "choice": "leave", + "probabilities": { + "stay": 0.01798621006309986, + "leave": 0.9820137619972229 + }, + "confidence": 0.8700206851739604 + } + }, + "usage": { + "input_tokens": 3874, + "output_tokens": 0 + } + }, + "graph_shapes": [ + [ + [ + "inputs_embeds", + [ + [ + 1, + 443, + 2560 + ], + [ + 1134080, + 2560, + 1 + ], + "torch.bfloat16", + "cuda:0" + ] + ], + [ + "position_ids", + [ + [ + 3, + 1, + 443 + ], + [ + 443, + 443, + 1 + ], + "torch.int64", + "cuda:0" + ] + ], + [ + "attention_mask", + [ + [ + 1, + 443 + ], + [ + 443, + 1 + ], + "torch.int64", + "cuda:0" + ] + ] + ], + [ + [ + "inputs_embeds", + [ + [ + 1, + 442, + 2560 + ], + [ + 1131520, + 2560, + 1 + ], + "torch.bfloat16", + "cuda:0" + ] + ], + [ + "position_ids", + [ + [ + 3, + 1, + 442 + ], + [ + 442, + 442, + 1 + ], + "torch.int64", + "cuda:0" + ] + ], + [ + "attention_mask", + [ + [ + 1, + 442 + ], + [ + 442, + 1 + ], + "torch.int64", + "cuda:0" + ] + ] + ], + [ + [ + "inputs_embeds", + [ + [ + 1, + 426, + 2560 + ], + [ + 1090560, + 2560, + 1 + ], + "torch.bfloat16", + "cuda:0" + ] + ], + [ + "position_ids", + [ + [ + 3, + 1, + 426 + ], + [ + 426, + 426, + 1 + ], + "torch.int64", + "cuda:0" + ] + ], + [ + "attention_mask", + [ + [ + 1, + 426 + ], + [ + 426, + 1 + ], + "torch.int64", + "cuda:0" + ] + ] + ], + [ + [ + "inputs_embeds", + [ + [ + 1, + 752, + 2560 + ], + [ + 1925120, + 2560, + 1 + ], + "torch.bfloat16", + "cuda:0" + ] + ], + [ + "position_ids", + [ + [ + 3, + 1, + 752 + ], + [ + 752, + 752, + 1 + ], + "torch.int64", + "cuda:0" + ] + ], + [ + "attention_mask", + [ + [ + 1, + 752 + ], + [ + 752, + 1 + ], + "torch.int64", + "cuda:0" + ] + ] + ], + [ + [ + "inputs_embeds", + [ + [ + 1, + 469, + 2560 + ], + [ + 1200640, + 2560, + 1 + ], + "torch.bfloat16", + "cuda:0" + ] + ], + [ + "position_ids", + [ + [ + 3, + 1, + 469 + ], + [ + 469, + 469, + 1 + ], + "torch.int64", + "cuda:0" + ] + ], + [ + "attention_mask", + [ + [ + 1, + 469 + ], + [ + 469, + 1 + ], + "torch.int64", + "cuda:0" + ] + ] + ], + [ + [ + "inputs_embeds", + [ + [ + 1, + 441, + 2560 + ], + [ + 1128960, + 2560, + 1 + ], + "torch.bfloat16", + "cuda:0" + ] + ], + [ + "position_ids", + [ + [ + 3, + 1, + 441 + ], + [ + 441, + 441, + 1 + ], + "torch.int64", + "cuda:0" + ] + ], + [ + "attention_mask", + [ + [ + 1, + 441 + ], + [ + 441, + 1 + ], + "torch.int64", + "cuda:0" + ] + ] + ], + [ + [ + "inputs_embeds", + [ + [ + 1, + 460, + 2560 + ], + [ + 1177600, + 2560, + 1 + ], + "torch.bfloat16", + "cuda:0" + ] + ], + [ + "position_ids", + [ + [ + 3, + 1, + 460 + ], + [ + 460, + 460, + 1 + ], + "torch.int64", + "cuda:0" + ] + ], + [ + "attention_mask", + [ + [ + 1, + 460 + ], + [ + 460, + 1 + ], + "torch.int64", + "cuda:0" + ] + ] + ] + ] + } + } + ], + "error": { + "type": "ValueError", + "message": "640x480-distinct-q8: graph probability difference exceeds 0.002" + } +} diff --git a/recipe/cua_s1/experiments/rtx4090-graph/long-rejected.json b/recipe/cua_s1/experiments/rtx4090-graph/long-rejected.json new file mode 100644 index 0000000..3f704bb --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-graph/long-rejected.json @@ -0,0 +1,61 @@ +{ + "status": "failed", + "repository": { + "revision": "809cacc70979b1b4e3a55b8b89be4691d09b0ce4", + "dirty": false, + "diff_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "untracked_files": [] + }, + "environment": { + "python": "3.12.13", + "gpu": "NVIDIA GeForce RTX 4090", + "compute_capability": [ + 8, + 9 + ], + "cuda": "13.0", + "driver": "595.71.05", + "torch_num_threads": 64, + "torch_num_interop_threads": 64, + "packages": { + "torch": "2.14.0", + "torchvision": "0.29.0", + "transformers": "5.17.0", + "peft": "0.21.0", + "pillow": "11.3.0", + "safetensors": "0.8.0", + "triton": "3.8.0" + }, + "reference_revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f", + "base_revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", + "adapter_revision": "16818868b0cc7813808aae4e87b417657046ab79", + "dtype": "bfloat16", + "adapter_merged": false + }, + "config": { + "warmup": 1, + "runs": 1, + "iterations": 2, + "cases": [ + "640x480-long-q8" + ], + "scope": "synchronized engine.predict; Graph captures model forward after vision, text embeddings and 3D positions; both variants use_cache=False" + }, + "cases": [ + { + "id": "640x480-long-q8", + "status": "rejected_graph", + "runs": [], + "max_graph_probability_difference": 0.001276806928217411, + "exact_eager_response_parity": true, + "changed_image_max_probability_difference": 0.001630336046218872, + "changed_image_replay_checked": true, + "changed_text_verb": "Open", + "changed_text_max_probability_difference": 0.05190175771713257 + } + ], + "error": { + "type": "ValueError", + "message": "640x480-long-q8: changed-text graph response differs" + } +} diff --git a/recipe/cua_s1/experiments/rtx4090-graph/paired.json b/recipe/cua_s1/experiments/rtx4090-graph/paired.json new file mode 100644 index 0000000..2c37c44 --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-graph/paired.json @@ -0,0 +1,948 @@ +{ + "status": "complete", + "repository": { + "revision": "809cacc70979b1b4e3a55b8b89be4691d09b0ce4", + "dirty": false, + "diff_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "untracked_files": [] + }, + "environment": { + "python": "3.12.13", + "gpu": "NVIDIA GeForce RTX 4090", + "compute_capability": [ + 8, + 9 + ], + "cuda": "13.0", + "driver": "595.71.05", + "torch_num_threads": 64, + "torch_num_interop_threads": 64, + "packages": { + "torch": "2.14.0", + "torchvision": "0.29.0", + "transformers": "5.17.0", + "peft": "0.21.0", + "pillow": "11.3.0", + "safetensors": "0.8.0", + "triton": "3.8.0" + }, + "reference_revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f", + "base_revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", + "adapter_revision": "16818868b0cc7813808aae4e87b417657046ab79", + "dtype": "bfloat16", + "adapter_merged": false + }, + "config": { + "warmup": 3, + "runs": 2, + "iterations": 20, + "cases": [ + "320x240-short-q2", + "320x240-short-q8", + "640x480-short-q8" + ], + "scope": "synchronized engine.predict; Graph captures model forward after vision, text embeddings and 3D positions; both variants use_cache=False" + }, + "cases": [ + { + "id": "320x240-short-q2", + "status": "complete", + "runs": [ + { + "orders": [ + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ] + ], + "eager": { + "samples_ms": [ + 178.98714821785688, + 178.94698679447174, + 181.7477010190487, + 179.02447655797005, + 179.70513179898262, + 188.00584878772497, + 182.1722537279129, + 181.05428852140903, + 180.29593862593174, + 180.51550164818764, + 181.09830748289824, + 184.3659933656454, + 183.19835979491472, + 189.10526297986507, + 186.95577885955572, + 185.2847896516323, + 182.49658029526472, + 180.83991203457117, + 180.26326596736908, + 182.047501206398 + ], + "p50_ms": 181.42300425097346, + "p95_ms": 189.10526297986507, + "peak_allocated_bytes": 9278395392 + }, + "graph": { + "samples_ms": [ + 99.46649335324764, + 99.66736473143101, + 99.43373315036297, + 99.61113706231117, + 100.67939478904009, + 100.00552143901587, + 100.93753784894943, + 100.21753422915936, + 100.39638727903366, + 100.5137525498867, + 101.5971265733242, + 101.17451194673777, + 101.65945999324322, + 101.8687766045332, + 100.4734355956316, + 100.16804467886686, + 100.4814226180315, + 100.16367491334677, + 99.93500914424658, + 99.76503066718578 + ], + "p50_ms": 100.30696075409651, + "p95_ms": 101.8687766045332, + "peak_allocated_bytes": 9229164544 + } + }, + { + "orders": [ + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ] + ], + "eager": { + "samples_ms": [ + 181.49447813630104, + 181.24750722199678, + 182.82124027609825, + 181.386043317616, + 182.55978543311357, + 181.48145824670792, + 203.13447900116444, + 221.09779436141253, + 194.26705595105886, + 185.78235805034637, + 184.78292878717184, + 183.35157074034214, + 185.15996169298887, + 181.08102958649397, + 184.59565937519073, + 182.34344571828842, + 186.14837154746056, + 183.20840504020452, + 181.35759606957436, + 187.10189685225487 + ], + "p50_ms": 183.27998789027333, + "p95_ms": 221.09779436141253, + "peak_allocated_bytes": 9278395392 + }, + "graph": { + "samples_ms": [ + 101.29308514297009, + 101.28161869943142, + 101.25336609780788, + 100.30057653784752, + 99.92608148604631, + 100.04294663667679, + 99.99412763863802, + 104.3145339936018, + 101.95666365325451, + 100.92813428491354, + 100.70684645324945, + 100.45408084988594, + 101.34581569582224, + 99.35656934976578, + 99.32926576584578, + 100.10671988129616, + 99.61647633463144, + 99.65330176055431, + 99.53794162720442, + 100.47016758471727 + ], + "p50_ms": 100.37732869386673, + "p95_ms": 104.3145339936018, + "peak_allocated_bytes": 9229164544 + } + } + ], + "max_graph_probability_difference": 0.0004209207836538553, + "exact_eager_response_parity": true, + "changed_image_max_probability_difference": 0.0006102193146944046, + "changed_image_replay_checked": true, + "changed_text_verb": "Open", + "changed_text_max_probability_difference": 0.0, + "changed_text_replay_checked": true, + "fixture_sha256": "d32998f61c3f875804c0161fe9eaca360d5eae5eb6e8adebde55b969ebbf666c", + "capture_ms": [ + 354.84773851931095 + ], + "graph_count": 1, + "capture_allocated_delta_bytes": [ + 17536000 + ], + "capture_reserved_delta_bytes": [ + -117440512 + ] + }, + { + "id": "320x240-short-q8", + "status": "complete", + "runs": [ + { + "orders": [ + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ] + ], + "eager": { + "samples_ms": [ + 668.1703086942434, + 661.7273576557636, + 670.3436989337206, + 662.6200983300805, + 658.7577443569899, + 661.2084629014134, + 667.4500061199069, + 667.8011370822787, + 669.8482995852828, + 674.5421048253775, + 667.4944339320064, + 696.425243280828, + 669.7804294526577, + 681.5349441021681, + 685.6235451996326, + 674.9389935284853, + 676.3926036655903, + 680.6337535381317, + 668.7559681013227, + 685.105879791081 + ], + "p50_ms": 669.8143645189703, + "p95_ms": 696.425243280828, + "peak_allocated_bytes": 9278395392 + }, + "graph": { + "samples_ms": [ + 334.9050274118781, + 335.53331810981035, + 336.81707084178925, + 337.0039938017726, + 336.862338706851, + 336.8708388879895, + 338.760232552886, + 337.6013021916151, + 338.1503336131573, + 338.8264523819089, + 338.06073665618896, + 340.8223055303097, + 337.35309541225433, + 337.98148203641176, + 337.5871293246746, + 337.56044041365385, + 338.4146289899945, + 340.97781404852867, + 337.4396376311779, + 337.4527534469962 + ], + "p50_ms": 337.57378486916423, + "p95_ms": 340.97781404852867, + "peak_allocated_bytes": 9228611584 + } + }, + { + "orders": [ + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ] + ], + "eager": { + "samples_ms": [ + 662.7661418169737, + 662.6765029504895, + 668.147873133421, + 662.6840988174081, + 665.4602214694023, + 664.9896763265133, + 679.8663623631, + 655.4316924884915, + 670.6828474998474, + 687.1210420504212, + 696.873327717185, + 688.733865506947, + 698.8846361637115, + 697.7157378569245, + 691.5281787514687, + 704.517406411469, + 697.2529869526625, + 707.6680846512318, + 681.4052481204271, + 692.3537524417043 + ], + "p50_ms": 684.2631450854242, + "p95_ms": 707.6680846512318, + "peak_allocated_bytes": 9278395392 + }, + "graph": { + "samples_ms": [ + 337.87758089601994, + 337.6439157873392, + 339.8454822599888, + 338.2702935487032, + 338.023885153234, + 338.01190461963415, + 337.82543893903494, + 337.6387460157275, + 338.4260581806302, + 340.1038786396384, + 342.44527108967304, + 338.00467569381, + 337.75717578828335, + 338.2086483761668, + 337.57196832448244, + 338.20668142288923, + 340.9330742433667, + 338.63368071615696, + 342.7293738350272, + 339.541207998991 + ], + "p50_ms": 338.207664899528, + "p95_ms": 342.7293738350272, + "peak_allocated_bytes": 9228611584 + } + } + ], + "max_graph_probability_difference": 0.0004209207836538553, + "exact_eager_response_parity": true, + "changed_image_max_probability_difference": 0.0006102193146944046, + "changed_image_replay_checked": true, + "changed_text_verb": "Open", + "changed_text_max_probability_difference": 0.0, + "changed_text_replay_checked": true, + "fixture_sha256": "c18af7ee94cfe01f0a583e7f528e5e2e62f95a619278a49c6655e1e685f6f869", + "capture_ms": [ + 347.23927825689316 + ], + "graph_count": 1, + "capture_allocated_delta_bytes": [ + 9016320 + ], + "capture_reserved_delta_bytes": [ + -20971520 + ] + }, + { + "id": "640x480-short-q8", + "status": "complete", + "runs": [ + { + "orders": [ + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ] + ], + "eager": { + "samples_ms": [ + 835.3018928319216, + 821.0041299462318, + 833.8440973311663, + 818.0805128067732, + 823.2853030785918, + 813.8000871986151, + 820.4618217423558, + 826.5390610322356, + 820.3238844871521, + 834.1717170551419, + 833.031078800559, + 825.5518153309822, + 826.0147143155336, + 831.871872767806, + 843.6629846692085, + 833.2261340692639, + 828.4875703975558, + 823.6940959468484, + 808.7752964347601, + 786.8381226435304 + ], + "p50_ms": 825.7832648232579, + "p95_ms": 843.6629846692085, + "peak_allocated_bytes": 9344734720 + }, + "graph": { + "samples_ms": [ + 560.4352308437228, + 564.091807231307, + 569.7002401575446, + 564.0029991045594, + 560.1353524252772, + 559.986375272274, + 564.1499171033502, + 560.6098817661405, + 562.7468749880791, + 573.2481554150581, + 560.8439510688186, + 564.9900492280722, + 561.7506671696901, + 563.0609495565295, + 567.6369117572904, + 563.500746153295, + 560.7292512431741, + 572.5699877366424, + 561.237077228725, + 561.6371585056186 + ], + "p50_ms": 562.9039122723043, + "p95_ms": 573.2481554150581, + "peak_allocated_bytes": 9295583744 + } + }, + { + "orders": [ + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ], + [ + "graph", + "eager" + ], + [ + "eager", + "graph" + ] + ], + "eager": { + "samples_ms": [ + 798.1038680300117, + 784.4302132725716, + 785.9589941799641, + 779.0926527231932, + 784.5668718218803, + 787.5849511474371, + 784.5131726935506, + 782.3704518377781, + 793.9427373930812, + 792.4138614907861, + 823.86863976717, + 785.027920268476, + 812.0255898684263, + 784.1441873461008, + 785.028986632824, + 788.4374503046274, + 792.6788404583931, + 791.0655057057738, + 792.9560402408242, + 783.1143923103809 + ], + "p50_ms": 786.7719726637006, + "p95_ms": 823.86863976717, + "peak_allocated_bytes": 9344734720 + }, + "graph": { + "samples_ms": [ + 560.0031344220042, + 561.2868629395962, + 561.0033022239804, + 560.7402548193932, + 561.2507117912173, + 561.7333678528666, + 561.242513358593, + 561.9296515360475, + 564.2945840954781, + 562.2324580326676, + 564.0178462490439, + 571.8395756557584, + 562.715851701796, + 562.0052712038159, + 561.7153150960803, + 561.7446731775999, + 560.6257217004895, + 561.3361159339547, + 561.3837065175176, + 561.815139837563 + ], + "p50_ms": 561.7243414744735, + "p95_ms": 571.8395756557584, + "peak_allocated_bytes": 9295583744 + } + } + ], + "max_graph_probability_difference": 0.0004209207836538553, + "exact_eager_response_parity": true, + "changed_image_max_probability_difference": 0.0007812343537807465, + "changed_image_replay_checked": true, + "changed_text_verb": "Open", + "changed_text_max_probability_difference": 0.0, + "changed_text_replay_checked": true, + "fixture_sha256": "038faab1159fdf610cb0c828b6c9e7cb12ee95a82539b9639f283530c99b5bf7", + "capture_ms": [ + 416.10068548470736 + ], + "graph_count": 1, + "capture_allocated_delta_bytes": [ + 17536000 + ], + "capture_reserved_delta_bytes": [ + -31457280 + ] + } + ] +} diff --git a/recipe/cua_s1/experiments/rtx4090-graph/verify_results.py b/recipe/cua_s1/experiments/rtx4090-graph/verify_results.py new file mode 100644 index 0000000..a7f84cf --- /dev/null +++ b/recipe/cua_s1/experiments/rtx4090-graph/verify_results.py @@ -0,0 +1,70 @@ +"""Recompute the published CUDA Graph experiment from saved raw samples.""" + +import json +import statistics +from pathlib import Path + +ROOT = Path(__file__).resolve().parent + + +def check(): + report = json.loads((ROOT / "paired.json").read_text()) + rejected = json.loads((ROOT / "distinct-rejected.json").read_text()) + long_rejected = json.loads((ROOT / "long-rejected.json").read_text()) + assert report["status"] == "complete" + assert report["repository"]["dirty"] is False + assert len(report["cases"]) == 3 + assert report["config"]["runs"] == 2 + assert report["config"]["iterations"] == 20 + count = 0 + for case in report["cases"]: + assert case["status"] == "complete" + assert case["exact_eager_response_parity"] + assert case["changed_image_replay_checked"] + assert case["changed_text_replay_checked"] + assert case["graph_count"] == 1 + assert len(case["capture_ms"]) == 1 + assert len(case["capture_allocated_delta_bytes"]) == 1 + assert len(case["capture_reserved_delta_bytes"]) == 1 + assert case["max_graph_probability_difference"] <= 0.002 + assert case["changed_image_max_probability_difference"] <= 0.002 + assert case["changed_text_max_probability_difference"] <= 0.002 + assert len(case["runs"]) == 2 + for run_index, run in enumerate(case["runs"]): + assert len(run["orders"]) == 20 + for sample_index, order in enumerate(run["orders"]): + expected = ["eager", "graph"] + if (run_index + sample_index) % 2: + expected.reverse() + assert order == expected + for variant in ("eager", "graph"): + values = run[variant]["samples_ms"] + assert len(values) == 20 and all(value > 0 for value in values) + ordered = sorted(values) + assert run[variant]["p50_ms"] == statistics.median(values) + assert run[variant]["p95_ms"] == ordered[19] + assert run[variant]["peak_allocated_bytes"] > 0 + count += len(values) + + assert rejected["status"] == "failed" + assert rejected["repository"]["dirty"] is False + assert len(rejected["cases"]) == 1 + failure = rejected["cases"][0] + assert failure["id"] == "640x480-distinct-q8" + assert failure["status"] == "rejected_graph" + assert failure["max_graph_probability_difference"] > 0.002 + assert len(failure["parity_diagnostic"]["graph_shapes"]) > 1 + assert long_rejected["status"] == "failed" + assert long_rejected["repository"]["dirty"] is False + assert len(long_rejected["cases"]) == 1 + failure = long_rejected["cases"][0] + assert failure["id"] == "640x480-long-q8" + assert failure["status"] == "rejected_graph" + assert failure["max_graph_probability_difference"] <= 0.002 + assert failure["changed_image_max_probability_difference"] <= 0.002 + assert failure["changed_text_max_probability_difference"] > 0.002 + print(f"Verified {count} paired samples across three cases and two rejected cases.") + + +if __name__ == "__main__": + check() From 63edd9bdc104c22363237e3970e36ec7d9871d3e Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Wed, 30 Sep 2026 00:17:46 +0800 Subject: [PATCH 24/26] chore: remove local experiment artifacts from PR Remove archived experiment outputs and assistant planning notes. Keep runtime code, reproducible tools, and model verification metadata unchanged. Link historical reports to an immutable commit and ignore future local artifacts. Remove only tests tied to the deleted historical evidence bundles. --- .gitignore | 4 + README.md | 2 +- recipe/cua_s1/README.md | 2 +- recipe/cua_s1/experiments/README.md | 136 ----- .../cua_s1/experiments/rtx4090/benchmark.json | 409 ------------- .../cua_s1/experiments/rtx4090/candidate.json | 536 ------------------ .../cua_s1/experiments/rtx4090/frontend.json | 79 --- .../cua_s1/experiments/rtx4090/packages.txt | 62 -- .../cua_s1/experiments/rtx4090/reference.json | 527 ----------------- 9 files changed, 6 insertions(+), 1751 deletions(-) delete mode 100644 recipe/cua_s1/experiments/README.md delete mode 100644 recipe/cua_s1/experiments/rtx4090/benchmark.json delete mode 100644 recipe/cua_s1/experiments/rtx4090/candidate.json delete mode 100644 recipe/cua_s1/experiments/rtx4090/frontend.json delete mode 100644 recipe/cua_s1/experiments/rtx4090/packages.txt delete mode 100644 recipe/cua_s1/experiments/rtx4090/reference.json diff --git a/.gitignore b/.gitignore index 07a95a7..b42bbc8 100644 --- a/.gitignore +++ b/.gitignore @@ -29,3 +29,7 @@ weights/ # macOS metadata .DS_Store + +# Local experiment outputs and assistant planning notes +/recipe/cua_s1/experiments/ +/docs/superpowers/ diff --git a/README.md b/README.md index 3bd7b64..2cca0d9 100644 --- a/README.md +++ b/README.md @@ -57,7 +57,7 @@ Validated coverage is listed by modality and execution path: | Model | Status | | --- | --- | | LAYA | [External worker](recipe/laya/README.md); model engine planned | -| [Cua-S1 4B 0.2](recipe/cua_s1/README.md) | Multimodal screenshot choices via Transformers/PEFT on RTX 4090 CUDA; [parity and measurements](recipe/cua_s1/experiments/README.md). Text serving, native CUDA kernels and Metal deferred. | +| [Cua-S1 4B 0.2](recipe/cua_s1/README.md) | Multimodal screenshot choices via Transformers/PEFT on RTX 4090 CUDA; [parity and measurements](https://github.com/Levius-Fubuki/system1-omni/blob/683d470669f19d5e9530cd8233727a0d4f1f8d29/recipe/cua_s1/experiments/README.md). Text serving, native CUDA kernels and Metal deferred. | CUDA and Metal coverage will be documented per model as implementations are added and validated. diff --git a/recipe/cua_s1/README.md b/recipe/cua_s1/README.md index 506d0c0..741a29e 100644 --- a/recipe/cua_s1/README.md +++ b/recipe/cua_s1/README.md @@ -14,7 +14,7 @@ worker uses the same request model name; deployment routing selects its modality ## Setup Run from this repository's root on Linux with an NVIDIA GPU. The measured CUDA -wheel, driver, GPU memory and results are recorded in [experiments](experiments/README.md). +wheel, driver, GPU memory and results are recorded in [experiments](https://github.com/Levius-Fubuki/system1-omni/blob/683d470669f19d5e9530cd8233727a0d4f1f8d29/recipe/cua_s1/experiments/README.md). Python 3.12 is required by the pinned environment. ```sh diff --git a/recipe/cua_s1/experiments/README.md b/recipe/cua_s1/experiments/README.md deleted file mode 100644 index 1fc834b..0000000 --- a/recipe/cua_s1/experiments/README.md +++ /dev/null @@ -1,136 +0,0 @@ -# RTX 4090 multimodal validation — 2026-09-27 - -This is a Transformers/PEFT CUDA baseline, with the adapter unmerged and full -logits, for the screenshot worker in [the recipe](../README.md). It does not -implement a native CUDA backend or claim a speedup over upstream. - -The checked-in GPU/HTTP results were measured at commit `74c95e5`. A subsequent -protocol-only revision aligned errors with the text-worker contract: `detail` -replaces `error`, malformed JSON/duplicate keys return 400, and `instructions` is -required (explicit `null` or an empty string omits the goal). The original -`frontend.json` therefore retains the **historical** duplicate-key status and -error-body hashes; it is not evidence for the revised error contract. Regression -tests cover the revised behavior without restarting the GPU instance. The -protocol revision passed 62 Python tests, 13 Rust tests, and 12 direct-versus- -frontend comparisons using the real worker HTTP handler with a CPU stub engine. -Those 12 checks validate transport and rejection behavior, not model inference. - -The generator now supplies `instructions: ""` for the second question of the -two-question fixture. This preserves its previous empty goal and prompt. Model -loading, image processing, prompt construction and scoring are unchanged; GPU -parity and performance have not been remeasured for the protocol revision. - -The 2026-09-29 review follow-up rejects image aspect ratios above 200:1 with -HTTP 422 before processing, matching pinned Transformers 5.17.0. Tests retain -acceptance at exactly 200:1 in either orientation. Lock cleanup checks now use -bounded acquisition, with a fixture that deliberately pauses the handler after -writing the response. All 70 Python tests passed with both pinned Pillow 11.3.0 -and Pillow 12.3.0; the 14 affected cleanup cases passed three additional runs in -the pinned environment. Rust's 13 tests, formatting and Clippy also passed. -These are CPU checks; the archived GPU measurements have not been rerun. - -## Environment and artifacts - -- One NVIDIA GeForce RTX 4090, 24,564 MiB, compute capability 8.9. -- Ubuntu 22.04 container; NVIDIA driver 595.71.05; PyTorch CUDA runtime 13.0. -- Python 3.12.13; torch 2.14.0, torchvision 0.29.0, Transformers 5.17.0, - PEFT 0.21.0, Pillow 11.3.0, safetensors 0.8.0, Triton 3.8.0. -- PyTorch reported 64 intra-op and 64 inter-op threads; no thread tuning applied. -- BF16 base, PEFT fp32 LoRA branches, no adapter merge, no quantization. -- Neither `flash-linear-attention` nor `causal-conv1d` is installed. The matching - upstream reference uses Transformers' PyTorch fallback implementations. -- All pinned weights passed size and SHA-256 verification. The lock contains - 9,342,907,469 base bytes and 186,638,393 adapter-repository bytes. Only the - `multimodal` adapter is loaded; all 178 target modules, including 50 visual - modules, are required at startup. - -Pinned revisions and the reference-source SHA-256 are present in every JSON -report. Full installed versions are in [packages.txt](rtx4090/packages.txt). -The numerical contract and dependency versions were fixed before comparisons. -No model weights or private screenshots are included. - -## Correctness - -| Check | Result | Evidence | -| --- | --- | --- | -| Processor tensor shapes, dtypes and SHA-256 values | Exact match on 9 question forwards across 8 requests | [reference.json](rtx4090/reference.json), [candidate.json](rtx4090/candidate.json) | -| Candidate fp32 probabilities | Exact match; maximum absolute difference **0** | Same reports | -| Multimodal LoRA attachment | 178 modules, visual modules present | [candidate.json](rtx4090/candidate.json) | -| Rust frontend vs direct worker | All 11 HTTP comparisons passed; status, content type and body bytes identical | [frontend.json](rtx4090/frontend.json) | -| CPU validation | 39 tests passed on local macOS and the Linux GPU host | `tests/cua_s1`, CPU CI workflow | - -Fixtures are generated by `evaluate_multimodal.py` using the pinned Pillow version. -They cover 320×240 and 640×480 screenshots, PNG/JPEG, 1 and 26 candidates, -structured/Unicode labels, special-token spellings and two questions sharing one -image. Processed prompts span 215–752 tokens. Hashes cover input IDs, attention -masks, image pixels and image-grid metadata, rather than just the selected option. -The fixtures establish integration parity, not GUI task accuracy or generalization. - -For the frontend test, PR #2's Rust frontend at -`0c91671ac7c8bd698b957b2c0df921de96e7e628` was built with `cargo build --release --locked` -on macOS. It forwarded to the Linux GPU worker over an SSH tunnel. This exercises -real inference and byte preservation; **network/HTTP latency is not benchmarked**. -Eight valid fixtures, health, malformed envelope and duplicate JSON keys were checked. - -Reproduce the HTTP check after generating the fixtures and starting both servers: - -```sh -python recipe/cua_s1/check_frontend.py \ - --worker http://127.0.0.1:8000 --frontend http://127.0.0.1:8080 \ - --fixtures /tmp/cua-evidence/fixtures --output /tmp/cua-evidence/frontend.json -``` - -## Warm engine performance - -[benchmark.json](rtx4090/benchmark.json) contains every sample and the operator -profile. One 640×480 PNG, three candidates, 456 processed tokens, batch size 1, -concurrency 1; five warmup requests followed by two runs of 50 requests. -`torch.cuda.synchronize()` brackets each measurement. p95 uses nearest rank. - -Timing covers `engine.predict`: chat-template application, processor work, host-to- -device transfer, forward pass, letter readout and answer construction. The request -has already been parsed and its image decoded. JSON parsing, image decoding, -HTTP, queueing, model load, artifact hashing and warmup are excluded. - -| Run | p50 | p95 | Serial throughput | Peak allocated | Peak reserved | -| --- | --- | --- | --- | --- | --- | -| 1 | 126.39 ms | 136.68 ms | 7.79 requests/s | 8.84 GiB | 9.07 GiB | -| 2 | 128.28 ms | 133.01 ms | 7.77 requests/s | 8.84 GiB | 9.07 GiB | - -The parity run's peak allocated memory across all nine forwards was 8.99 GiB. -These bounds describe the measured fixtures, not every request admitted by the -worker's 4096-token limit or a concurrent/batched deployment. - -Measured candidate construction, including weight hashing, was 19.94 s in the -parity process and 18.94 s in the benchmark process. Their initial 224×224 warmups -were 1.82 s and 1.63 s. Upstream load was 16.82 s plus 9.54 s of separately measured -artifact verification; its first 320×240 warmup was 3.67 s. These are individual -observations after importing PyTorch and probing the GPU, with different warmup -shapes and filesystem-cache histories; they are not a cold-start speed comparison. -Per-fixture timings in the parity reports are also single observations; the -reference includes image opening while candidate timing covers `score` only. - -## Profiling and the next optimization boundary - -A separate profiled inference, excluded from the latency samples, reported: - -| Operator | Calls | Self CUDA time | -| --- | --- | --- | -| `aten::mm` | 605 | 35.42 ms | -| `aten::copy_` | 1,642 | 9.55 ms | -| `aten::bmm` | 817 | 9.11 ms | -| `aten::addmm` | 98 | 5.89 ms | -| `aten::mul` | 1,103 | 5.76 ms | - -These are instrumented operator totals, not percentages of request wall time. -The raw profile includes both framework operators and CUDA kernels, which overlap; -do not add parent and child events or add kernel time to its enclosing operator. - -Matrix multiplication dominates the observed operator totals. A subsequent CUDA -optimization should first attribute those GEMMs and copies to vision, language -and LoRA branches using shapes/module ranges, then compare one bounded change -against this baseline. This profile alone does not justify replacing a specific -kernel or claiming a speedup. Gated DeltaNet/causal-convolution backend work should -be coordinated with the text-engine contributor because those language layers are -shared. This PR keeps the exact upstream execution path and contributes the -multimodal correctness and performance baseline needed for that work. diff --git a/recipe/cua_s1/experiments/rtx4090/benchmark.json b/recipe/cua_s1/experiments/rtx4090/benchmark.json deleted file mode 100644 index 7b69afc..0000000 --- a/recipe/cua_s1/experiments/rtx4090/benchmark.json +++ /dev/null @@ -1,409 +0,0 @@ -{ - "environment": { - "python": "3.12.13", - "gpu": "NVIDIA GeForce RTX 4090", - "compute_capability": [ - 8, - 9 - ], - "cuda": "13.0", - "driver": "595.71.05", - "torch_num_threads": 64, - "torch_num_interop_threads": 64, - "packages": { - "torch": "2.14.0", - "torchvision": "0.29.0", - "transformers": "5.17.0", - "peft": "0.21.0", - "pillow": "11.3.0", - "safetensors": "0.8.0", - "triton": "3.8.0" - }, - "reference_revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f", - "base_revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", - "adapter_revision": "16818868b0cc7813808aae4e87b417657046ab79", - "dtype": "bfloat16", - "adapter_merged": false - }, - "mode": "benchmark", - "cases": [], - "reference_source": { - "path": "libs/cua-s1/python/src/cua_s1/four_b.py", - "sha256": "7ed1adfd92223bef7d533db7efbb4cbf468c4936c4380ae42aee12097e3b9ea7", - "revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f" - }, - "load_ms": 18941.51310157031, - "warmup_ms": 1633.873094804585, - "adapter_modules": 178, - "benchmark": { - "case": "medium", - "batch_size": 1, - "concurrency": 1, - "warmup_requests": 5, - "runs": [ - { - "run": 1, - "latencies_ms": [ - 125.8343830704689, - 127.36847903579473, - 125.82478113472462, - 125.89417397975922, - 146.41341753304005, - 127.77413055300713, - 127.22665630280972, - 125.83817914128304, - 126.10162515193224, - 127.15142965316772, - 126.42081826925278, - 126.38038955628872, - 126.02570466697216, - 128.5353172570467, - 129.56660240888596, - 129.32745181024075, - 126.28413271158934, - 126.18042714893818, - 133.06267280131578, - 126.3929232954979, - 131.68340362608433, - 126.76465138792992, - 125.68666227161884, - 126.71545054763556, - 125.96531771123409, - 125.74396748095751, - 130.0713624805212, - 132.96419847756624, - 131.16213120520115, - 126.18762347847223, - 125.84684416651726, - 126.00735854357481, - 125.77000726014376, - 126.28292944282293, - 125.9002760052681, - 130.30958734452724, - 136.85170747339725, - 134.48695000261068, - 136.67899277061224, - 134.1363089159131, - 133.8470932096243, - 126.33792497217655, - 126.30761601030827, - 126.43217574805021, - 125.64307544380426, - 125.50272978842258, - 125.40635839104652, - 125.05617458373308, - 125.54042227566242, - 127.74347327649593 - ], - "p50_ms": 126.3866564258933, - "p95_ms": 136.67899277061224, - "requests_per_second_serial": 7.792244462582349, - "peak_allocated_bytes": 9496202240, - "peak_reserved_bytes": 9741271040 - }, - { - "run": 2, - "latencies_ms": [ - 126.58042088150978, - 126.69678498059511, - 126.67341157793999, - 129.0692137554288, - 127.07117944955826, - 129.27887961268425, - 133.4229400381446, - 128.44505812972784, - 127.24453490227461, - 126.93716865032911, - 130.17353229224682, - 131.4986888319254, - 130.03864511847496, - 131.02801516652107, - 129.7577489167452, - 128.6515649408102, - 132.58606754243374, - 128.7766983732581, - 131.9235684350133, - 128.00912745296955, - 127.52761784940958, - 129.2492775246501, - 132.3700835928321, - 128.50904930382967, - 127.91914585977793, - 131.54291920363903, - 129.6907477080822, - 133.75771697610617, - 129.1659427806735, - 126.58135313540697, - 126.16921309381723, - 126.81071180850267, - 128.0105598270893, - 128.40583361685276, - 127.4806559085846, - 127.57191434502602, - 128.10698058456182, - 127.0896615460515, - 127.29146610945463, - 133.00949800759554, - 128.90154495835304, - 128.37096769362688, - 127.91174557060003, - 127.8772447258234, - 128.1898096203804, - 127.69030872732401, - 126.3129971921444, - 129.61805891245604, - 126.81897450238466, - 126.8136901780963 - ], - "p50_ms": 128.28038865700364, - "p95_ms": 133.00949800759554, - "requests_per_second_serial": 7.765628438386997, - "peak_allocated_bytes": 9496202240, - "peak_reserved_bytes": 9741271040 - } - ] - }, - "profile": [ - { - "op": "aten::matmul", - "count": 1422, - "device_time_us": 44527.040000000154, - "self_device_time_us": 0.0, - "cpu_time_us": 53924.26100000019, - "self_cpu_time_us": 9931.453000001111 - }, - { - "op": "aten::linear", - "count": 703, - "device_time_us": 41310.13700000033, - "self_device_time_us": 0.0, - "cpu_time_us": 24486.469999999994, - "self_cpu_time_us": 1650.2199999998538 - }, - { - "op": "aten::mm", - "count": 605, - "device_time_us": 35415.818000000334, - "self_device_time_us": 35415.818000000334, - "cpu_time_us": 13464.22999999985, - "self_cpu_time_us": 8533.79799999894 - }, - { - "op": "ampere_bf16_s1688gemm_bf16_64x128_sliced1x2_ldg8_f2f_tn", - "count": 96, - "device_time_us": 17010.658999999934, - "self_device_time_us": 17010.658999999934, - "cpu_time_us": 0, - "self_cpu_time_us": 0 - }, - { - "op": "aten::copy_", - "count": 1642, - "device_time_us": 9549.038000000242, - "self_device_time_us": 9549.038000000242, - "cpu_time_us": 25915.56300000043, - "self_cpu_time_us": 9625.815000000488 - }, - { - "op": "aten::bmm", - "count": 817, - "device_time_us": 9111.22199999982, - "self_device_time_us": 9109.750999999822, - "cpu_time_us": 20146.271999999823, - "self_cpu_time_us": 16179.460999999617 - }, - { - "op": "ampere_bf16_s1688gemm_bf16_128x128_ldg8_f2f_stages_32x1_tn", - "count": 56, - "device_time_us": 6589.621000000137, - "self_device_time_us": 6589.621000000137, - "cpu_time_us": 0, - "self_cpu_time_us": 0 - }, - { - "op": "aten::addmm", - "count": 98, - "device_time_us": 5894.318999999992, - "self_device_time_us": 5894.318999999992, - "cpu_time_us": 2576.6010000000297, - "self_cpu_time_us": 1777.2650000000776 - }, - { - "op": "aten::mul", - "count": 1103, - "device_time_us": 5763.554999999398, - "self_device_time_us": 5763.554999999398, - "cpu_time_us": 13280.975000000395, - "self_cpu_time_us": 8342.606000000327 - }, - { - "op": "aten::to", - "count": 1361, - "device_time_us": 5300.117000000242, - "self_device_time_us": 0.0, - "cpu_time_us": 28756.462000000047, - "self_cpu_time_us": 1621.334000000551 - }, - { - "op": "aten::_to_copy", - "count": 1080, - "device_time_us": 5300.117000000242, - "self_device_time_us": 0.0, - "cpu_time_us": 27135.127999999495, - "self_cpu_time_us": 4165.844999999095 - }, - { - "op": "ampere_bf16_s16816gemm_bf16_128x64_ldg8_f2f_tn", - "count": 1, - "device_time_us": 4485.06700000001, - "self_device_time_us": 4485.06700000001, - "cpu_time_us": 0, - "self_cpu_time_us": 0 - }, - { - "op": "aten::add", - "count": 1009, - "device_time_us": 4335.962000000129, - "self_device_time_us": 4335.962000000129, - "cpu_time_us": 11608.1780000002, - "self_cpu_time_us": 7166.728000000563 - }, - { - "op": "ampere_bf16_s1688gemm_bf16_128x64_sliced1x2_ldg8_relu_f2f_tn", - "count": 50, - "device_time_us": 3960.761000000013, - "self_device_time_us": 3960.761000000013, - "cpu_time_us": 0, - "self_cpu_time_us": 0 - }, - { - "op": "aten::linalg_solve_triangular", - "count": 48, - "device_time_us": 3340.373000000007, - "self_device_time_us": 2853.693999999952, - "cpu_time_us": 4383.135000000191, - "self_cpu_time_us": 1135.9290000003602 - }, - { - "op": "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast > >(at::TensorIteratorBase&, at::native::BinaryFunctor > const&)::{lambda(int)#1})", - "count": 668, - "device_time_us": 3093.801999999436, - "self_device_time_us": 3093.801999999436, - "cpu_time_us": 0, - "self_cpu_time_us": 0 - }, - { - "op": "aten::convolution", - "count": 25, - "device_time_us": 3044.873999999925, - "self_device_time_us": 0.0, - "cpu_time_us": 2021.7800000000425, - "self_cpu_time_us": 143.51700000008714 - }, - { - "op": "aten::_convolution", - "count": 25, - "device_time_us": 3044.873999999925, - "self_device_time_us": 0.0, - "cpu_time_us": 1878.2629999999554, - "self_cpu_time_us": 489.0389999998333 - }, - { - "op": "void batch_trsm_left_kernel(cublasTrsmBatchParams2, float, float const*, int)", - "count": 48, - "device_time_us": 2853.693999999952, - "self_device_time_us": 2853.693999999952, - "cpu_time_us": 0, - "self_cpu_time_us": 0 - }, - { - "op": "ampere_bf16_s1688gemm_bf16_64x64_sliced1x4_ldg8_f2f_tn", - "count": 32, - "device_time_us": 2847.620000000141, - "self_device_time_us": 2847.620000000141, - "cpu_time_us": 0, - "self_cpu_time_us": 0 - }, - { - "op": "aten::clone", - "count": 141, - "device_time_us": 2841.203000000127, - "self_device_time_us": 0.0, - "cpu_time_us": 4514.54400000007, - "self_cpu_time_us": 654.2669999996788 - }, - { - "op": "ampere_sgemm_128x128_tn", - "count": 240, - "device_time_us": 2783.6780000002327, - "self_device_time_us": 2783.6780000002327, - "cpu_time_us": 0, - "self_cpu_time_us": 0 - }, - { - "op": "void at::native::unrolled_elementwise_kernel, std::array, 4, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1> >(int, at::native::CUDAFunctor_add, std::array, TrivialOffsetCalculator<2, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<2>, at::native::memory::StoreWithCast<1>)", - "count": 178, - "device_time_us": 2525.99999999996, - "self_device_time_us": 2525.99999999996, - "cpu_time_us": 0, - "self_cpu_time_us": 0 - }, - { - "op": "ampere_sgemm_128x128_nn", - "count": 192, - "device_time_us": 2428.904999999824, - "self_device_time_us": 2428.904999999824, - "cpu_time_us": 0, - "self_cpu_time_us": 0 - }, - { - "op": "ampere_sgemm_128x128_nt", - "count": 192, - "device_time_us": 2347.072999999873, - "self_device_time_us": 2347.072999999873, - "cpu_time_us": 0, - "self_cpu_time_us": 0 - }, - { - "op": "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#12}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast(at::TensorIteratorBase&, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#12}::operator()() const::{lambda(c10::BFloat16)#1} const&)::{lambda(int)#1})", - "count": 112, - "device_time_us": 2314.617000000122, - "self_device_time_us": 2314.617000000122, - "cpu_time_us": 0, - "self_cpu_time_us": 0 - }, - { - "op": "aten::conv1d", - "count": 24, - "device_time_us": 2197.6299999999246, - "self_device_time_us": 0.0, - "cpu_time_us": 1939.474999999984, - "self_cpu_time_us": 93.11899999994057 - }, - { - "op": "aten::scaled_dot_product_attention", - "count": 32, - "device_time_us": 2140.842999999986, - "self_device_time_us": 0.0, - "cpu_time_us": 2570.106999999978, - "self_cpu_time_us": 379.762999999959 - }, - { - "op": "aten::_scaled_dot_product_flash_attention", - "count": 32, - "device_time_us": 2140.842999999986, - "self_device_time_us": 0.0, - "cpu_time_us": 2190.344000000019, - "self_cpu_time_us": 310.61200000015015 - }, - { - "op": "aten::_flash_attention_forward", - "count": 32, - "device_time_us": 2140.842999999986, - "self_device_time_us": 2140.842999999986, - "cpu_time_us": 1620.5300000000316, - "self_cpu_time_us": 539.4930000000277 - } - ], - "peak_allocated_bytes": 9496202240 -} \ No newline at end of file diff --git a/recipe/cua_s1/experiments/rtx4090/candidate.json b/recipe/cua_s1/experiments/rtx4090/candidate.json deleted file mode 100644 index f8e4a92..0000000 --- a/recipe/cua_s1/experiments/rtx4090/candidate.json +++ /dev/null @@ -1,536 +0,0 @@ -{ - "environment": { - "python": "3.12.13", - "gpu": "NVIDIA GeForce RTX 4090", - "compute_capability": [ - 8, - 9 - ], - "cuda": "13.0", - "driver": "595.71.05", - "torch_num_threads": 64, - "torch_num_interop_threads": 64, - "packages": { - "torch": "2.14.0", - "torchvision": "0.29.0", - "transformers": "5.17.0", - "peft": "0.21.0", - "pillow": "11.3.0", - "safetensors": "0.8.0", - "triton": "3.8.0" - }, - "reference_revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f", - "base_revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", - "adapter_revision": "16818868b0cc7813808aae4e87b417657046ab79", - "dtype": "bfloat16", - "adapter_merged": false - }, - "mode": "candidate", - "cases": [ - { - "name": "small", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 236 - ], - "dtype": "torch.int64", - "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" - }, - "attention_mask": { - "shape": [ - 1, - 236 - ], - "dtype": "torch.int64", - "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 236 - ], - "dtype": "torch.int64", - "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" - }, - "pixel_values": { - "shape": [ - 320, - 1536 - ], - "dtype": "torch.float32", - "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" - } - }, - "probabilities": [ - 0.9958575367927551, - 0.0005507932510226965, - 0.003591623157262802 - ], - "max_abs_difference": 0.0, - "latency_ms": 127.26952508091927 - }, - { - "name": "medium", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 456 - ], - "dtype": "torch.int64", - "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" - }, - "attention_mask": { - "shape": [ - 1, - 456 - ], - "dtype": "torch.int64", - "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 456 - ], - "dtype": "torch.int64", - "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" - }, - "pixel_values": { - "shape": [ - 1200, - 1536 - ], - "dtype": "torch.float32", - "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" - } - }, - "probabilities": [ - 0.9958575367927551, - 0.0005507932510226965, - 0.003591623157262802 - ], - "max_abs_difference": 0.0, - "latency_ms": 126.0456619784236 - }, - { - "name": "jpeg", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 456 - ], - "dtype": "torch.int64", - "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" - }, - "attention_mask": { - "shape": [ - 1, - 456 - ], - "dtype": "torch.int64", - "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 456 - ], - "dtype": "torch.int64", - "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" - }, - "pixel_values": { - "shape": [ - 1200, - 1536 - ], - "dtype": "torch.float32", - "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" - } - }, - "probabilities": [ - 0.9936226010322571, - 0.0011634123511612415, - 0.005214052740484476 - ], - "max_abs_difference": 0.0, - "latency_ms": 121.78163509815931 - }, - { - "name": "single", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 431 - ], - "dtype": "torch.int64", - "sha256": "c4d7b1102e94984504efa938052a0bba3639ba85f9917de3e8af5426ceefd16b" - }, - "attention_mask": { - "shape": [ - 1, - 431 - ], - "dtype": "torch.int64", - "sha256": "3419eb840bd7f9d9e4b1fa6aaea783bae7a4752068701794687337702c2d8968" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 431 - ], - "dtype": "torch.int64", - "sha256": "077d91126e88fd3e8ba97a2d8079c28a4d5da388e56c89ca0e584fd5ad4b3641" - }, - "pixel_values": { - "shape": [ - 1200, - 1536 - ], - "dtype": "torch.float32", - "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" - } - }, - "probabilities": [ - 1.0 - ], - "max_abs_difference": 0.0, - "latency_ms": 117.80334264039993 - }, - { - "name": "26-options", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 752 - ], - "dtype": "torch.int64", - "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" - }, - "attention_mask": { - "shape": [ - 1, - 752 - ], - "dtype": "torch.int64", - "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 752 - ], - "dtype": "torch.int64", - "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" - }, - "pixel_values": { - "shape": [ - 1200, - 1536 - ], - "dtype": "torch.float32", - "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" - } - }, - "probabilities": [ - 0.07546718418598175, - 0.00034948240499943495, - 0.263406366109848, - 0.557631254196167, - 0.009013270027935505, - 0.01908109337091446, - 0.007019542157649994, - 0.016839005053043365, - 0.009013270027935505, - 0.0025823453906923532, - 0.004824455827474594, - 0.003315796609967947, - 0.002011132426559925, - 0.0022789116483181715, - 0.00619472423568368, - 0.0010764816543087363, - 0.0037572900764644146, - 0.0006529190577566624, - 0.002011132426559925, - 0.0012198134791105986, - 0.00044874430750496686, - 0.0005084939184598625, - 0.003315796609967947, - 0.0013822298496961594, - 0.0017748181708157063, - 0.004824455827474594 - ], - "max_abs_difference": 0.0, - "latency_ms": 141.8488211929798 - }, - { - "name": "structured", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 469 - ], - "dtype": "torch.int64", - "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" - }, - "attention_mask": { - "shape": [ - 1, - 469 - ], - "dtype": "torch.int64", - "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 469 - ], - "dtype": "torch.int64", - "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" - }, - "pixel_values": { - "shape": [ - 1200, - 1536 - ], - "dtype": "torch.float32", - "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" - } - }, - "probabilities": [ - 0.07443060725927353, - 0.9067503809928894, - 0.01881900243461132 - ], - "max_abs_difference": 0.0, - "latency_ms": 121.30219116806984 - }, - { - "name": "special-token", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 441 - ], - "dtype": "torch.int64", - "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" - }, - "attention_mask": { - "shape": [ - 1, - 441 - ], - "dtype": "torch.int64", - "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 441 - ], - "dtype": "torch.int64", - "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" - }, - "pixel_values": { - "shape": [ - 1200, - 1536 - ], - "dtype": "torch.float32", - "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" - } - }, - "probabilities": [ - 0.531209409236908, - 0.4687906503677368 - ], - "max_abs_difference": 0.0, - "latency_ms": 117.51110758632421 - }, - { - "name": "two-questions", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 236 - ], - "dtype": "torch.int64", - "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" - }, - "attention_mask": { - "shape": [ - 1, - 236 - ], - "dtype": "torch.int64", - "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 236 - ], - "dtype": "torch.int64", - "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" - }, - "pixel_values": { - "shape": [ - 320, - 1536 - ], - "dtype": "torch.float32", - "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" - } - }, - "probabilities": [ - 0.9958575367927551, - 0.0005507932510226965, - 0.003591623157262802 - ], - "max_abs_difference": 0.0, - "latency_ms": 103.49029209464788 - }, - { - "name": "two-questions", - "question": "second", - "inputs": { - "input_ids": { - "shape": [ - 1, - 215 - ], - "dtype": "torch.int64", - "sha256": "1bc665c3f5aa0134e368d1a9edf0e652ec604cf43e969d59b14f696a4cf5c9c3" - }, - "attention_mask": { - "shape": [ - 1, - 215 - ], - "dtype": "torch.int64", - "sha256": "bbdd8ad88f622ea9585a6b471f3ef6810a0c3374e43dbcb747e3077de4e6e674" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 215 - ], - "dtype": "torch.int64", - "sha256": "6dc930bb14d93a028e6d2db398b391c4fe5af99184ec6625d38d2f7820e182f3" - }, - "pixel_values": { - "shape": [ - 320, - 1536 - ], - "dtype": "torch.float32", - "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" - } - }, - "probabilities": [ - 0.22270014882087708, - 0.7772998809814453 - ], - "max_abs_difference": 0.0, - "latency_ms": 104.30925991386175 - } - ], - "reference_source": { - "path": "libs/cua-s1/python/src/cua_s1/four_b.py", - "sha256": "7ed1adfd92223bef7d533db7efbb4cbf468c4936c4380ae42aee12097e3b9ea7", - "revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f" - }, - "load_ms": 19939.03631903231, - "warmup_ms": 1815.6465897336602, - "adapter_modules": 178, - "peak_allocated_bytes": 9657058304 -} \ No newline at end of file diff --git a/recipe/cua_s1/experiments/rtx4090/frontend.json b/recipe/cua_s1/experiments/rtx4090/frontend.json deleted file mode 100644 index 39cee2e..0000000 --- a/recipe/cua_s1/experiments/rtx4090/frontend.json +++ /dev/null @@ -1,79 +0,0 @@ -[ - { - "name": "health", - "status": 200, - "content_type": "application/json", - "body_sha256": "f54feed005f2b4d1d6f2398a306d13aeaaa0c90aea20b5cca2a4de4ecab5bdd7", - "identical": true - }, - { - "name": "26-options", - "status": 200, - "content_type": "application/json", - "body_sha256": "64889fe4b0e85dac1c361d29a4367ed27fe63ceb75d94166ee867ba11ceb83d3", - "identical": true - }, - { - "name": "jpeg", - "status": 200, - "content_type": "application/json", - "body_sha256": "aeedac2faea6c8d9cc6e8636751833f5ee03b88dc8092f8a9d93e4320eb3f887", - "identical": true - }, - { - "name": "medium", - "status": 200, - "content_type": "application/json", - "body_sha256": "1d6041c8144e070b2d766cc1c85c52764addcb4745da88e96f94c5058678e62c", - "identical": true - }, - { - "name": "single", - "status": 200, - "content_type": "application/json", - "body_sha256": "6e9194fc25bc7ec8741dabd52ee4dfb3412b5c18eac22c2935b3ba96989c7a8c", - "identical": true - }, - { - "name": "small", - "status": 200, - "content_type": "application/json", - "body_sha256": "51fa5f1cf910140c958cc2c6ca3738699527dd47cee58809060ac6017400602e", - "identical": true - }, - { - "name": "special-token", - "status": 200, - "content_type": "application/json", - "body_sha256": "38646659005cdc82b81a5bac4ab8120f7f1e1b16bdb1c610fa72e5794ed5a439", - "identical": true - }, - { - "name": "structured", - "status": 200, - "content_type": "application/json", - "body_sha256": "21fe1ab16324d937eb8f9c6c692ccb1d1ad41d9d01cb078440dee0fde8990920", - "identical": true - }, - { - "name": "two-questions", - "status": 200, - "content_type": "application/json", - "body_sha256": "3f8dd307c92bf5dbf7e1ff1c928d3961265516e587ce162f905ded363f6764c1", - "identical": true - }, - { - "name": "invalid", - "status": 422, - "content_type": "application/json", - "body_sha256": "866753c516b9090204f79318fa8d289f42ef1650821ef4b974bc915ec2836832", - "identical": true - }, - { - "name": "duplicate", - "status": 422, - "content_type": "application/json", - "body_sha256": "1175f6c373a386204fa01db801fac92f0b772d5f2ef09a43e788ac72ae156a27", - "identical": true - } -] \ No newline at end of file diff --git a/recipe/cua_s1/experiments/rtx4090/packages.txt b/recipe/cua_s1/experiments/rtx4090/packages.txt deleted file mode 100644 index 646c8bb..0000000 --- a/recipe/cua_s1/experiments/rtx4090/packages.txt +++ /dev/null @@ -1,62 +0,0 @@ -accelerate==1.15.0 -annotated-doc==0.0.5 -anyio==4.15.1 -certifi==2026.7.22 -click==8.5.0 -cuda-bindings==13.4.2 -cuda-pathfinder==1.8.2 -cuda-toolkit==13.0.3.0 -filelock==4.0.1 -fsspec==2026.9.0 -h11==0.16.0 -hf-xet==1.6.0 -httpcore==1.0.9 -httpx==0.28.1 -huggingface-hub==1.32.0 -idna==3.20 -iniconfig==2.3.0 -jinja2==3.1.6 -markdown-it-py==4.2.0 -markupsafe==3.0.3 -mdurl==0.1.2 -mpmath==1.3.0 -networkx==3.6.1 -numpy==2.5.3 -nvidia-cublas==13.1.1.3 -nvidia-cuda-cupti==13.0.85 -nvidia-cuda-nvrtc==13.0.88 -nvidia-cuda-runtime==13.0.96 -nvidia-cudnn-cu13==9.24.0.43 -nvidia-cufft==12.0.0.61 -nvidia-cufile==1.15.1.6 -nvidia-curand==10.4.0.35 -nvidia-cusolver==12.0.4.66 -nvidia-cusparse==12.6.3.3 -nvidia-cusparselt-cu13==0.8.1 -nvidia-nccl-cu13==2.30.7 -nvidia-nvjitlink==13.4.92 -nvidia-nvshmem-cu13==3.4.5 -nvidia-nvtx==13.0.85 -packaging==26.3 -peft==0.21.0 -pillow==11.3.0 -pluggy==1.6.0 -psutil==7.2.2 -pygments==2.21.0 -pytest==9.1.1 -pyyaml==6.0.3 -regex==2026.9.10 -rich==15.0.0 -ruff==0.16.8 -safetensors==0.8.0 -setuptools==84.0.0 -shellingham==1.5.4 -sympy==1.14.0 -tokenizers==0.23.2 -torch==2.14.0 -torchvision==0.29.0 -tqdm==4.70.1 -transformers==5.17.0 -triton==3.8.0 -typer==0.27.2 -typing-extensions==4.16.0 diff --git a/recipe/cua_s1/experiments/rtx4090/reference.json b/recipe/cua_s1/experiments/rtx4090/reference.json deleted file mode 100644 index eaba46f..0000000 --- a/recipe/cua_s1/experiments/rtx4090/reference.json +++ /dev/null @@ -1,527 +0,0 @@ -{ - "environment": { - "python": "3.12.13", - "gpu": "NVIDIA GeForce RTX 4090", - "compute_capability": [ - 8, - 9 - ], - "cuda": "13.0", - "driver": "595.71.05", - "torch_num_threads": 64, - "torch_num_interop_threads": 64, - "packages": { - "torch": "2.14.0", - "torchvision": "0.29.0", - "transformers": "5.17.0", - "peft": "0.21.0", - "pillow": "11.3.0", - "safetensors": "0.8.0", - "triton": "3.8.0" - }, - "reference_revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f", - "base_revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", - "adapter_revision": "16818868b0cc7813808aae4e87b417657046ab79", - "dtype": "bfloat16", - "adapter_merged": false - }, - "mode": "reference", - "cases": [ - { - "name": "small", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 236 - ], - "dtype": "torch.int64", - "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" - }, - "attention_mask": { - "shape": [ - 1, - 236 - ], - "dtype": "torch.int64", - "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 236 - ], - "dtype": "torch.int64", - "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" - }, - "pixel_values": { - "shape": [ - 320, - 1536 - ], - "dtype": "torch.float32", - "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" - } - }, - "probabilities": [ - 0.9958575367927551, - 0.0005507932510226965, - 0.003591623157262802 - ], - "latency_ms": 147.01103698462248 - }, - { - "name": "medium", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 456 - ], - "dtype": "torch.int64", - "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" - }, - "attention_mask": { - "shape": [ - 1, - 456 - ], - "dtype": "torch.int64", - "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 456 - ], - "dtype": "torch.int64", - "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" - }, - "pixel_values": { - "shape": [ - 1200, - 1536 - ], - "dtype": "torch.float32", - "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" - } - }, - "probabilities": [ - 0.9958575367927551, - 0.0005507932510226965, - 0.003591623157262802 - ], - "latency_ms": 149.6963743120432 - }, - { - "name": "jpeg", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 456 - ], - "dtype": "torch.int64", - "sha256": "1e44867ea2f54730abf507d49e4db88735868bfc133cf98d4cb5c49fc001adad" - }, - "attention_mask": { - "shape": [ - 1, - 456 - ], - "dtype": "torch.int64", - "sha256": "c7e61368825c7c260dfd74e531d207b536301fb298dbd9b8cf341fc9ba9d42ff" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 456 - ], - "dtype": "torch.int64", - "sha256": "90259c2d1bd52b91ab67913e12e53db66a07bfc19ffefa42978366f637e9d0ef" - }, - "pixel_values": { - "shape": [ - 1200, - 1536 - ], - "dtype": "torch.float32", - "sha256": "5a78a7f25b40888ad5c134d02826d691c27707384603242b99897cc623817bd8" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" - } - }, - "probabilities": [ - 0.9936226010322571, - 0.0011634123511612415, - 0.005214052740484476 - ], - "latency_ms": 137.3040061444044 - }, - { - "name": "single", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 431 - ], - "dtype": "torch.int64", - "sha256": "c4d7b1102e94984504efa938052a0bba3639ba85f9917de3e8af5426ceefd16b" - }, - "attention_mask": { - "shape": [ - 1, - 431 - ], - "dtype": "torch.int64", - "sha256": "3419eb840bd7f9d9e4b1fa6aaea783bae7a4752068701794687337702c2d8968" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 431 - ], - "dtype": "torch.int64", - "sha256": "077d91126e88fd3e8ba97a2d8079c28a4d5da388e56c89ca0e584fd5ad4b3641" - }, - "pixel_values": { - "shape": [ - 1200, - 1536 - ], - "dtype": "torch.float32", - "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" - } - }, - "probabilities": [ - 1.0 - ], - "latency_ms": 135.01203525811434 - }, - { - "name": "26-options", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 752 - ], - "dtype": "torch.int64", - "sha256": "726f7d304140077e32490233aba734494431d93b7e2885bcb72d8b1c730e022b" - }, - "attention_mask": { - "shape": [ - 1, - 752 - ], - "dtype": "torch.int64", - "sha256": "389336aff30134c9af5da75eb0a9694eef903cde261cd8741f8aafae5ff94dc7" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 752 - ], - "dtype": "torch.int64", - "sha256": "e4cb23e2c28d9f1909d0269d3b145ba19f7efb4176b5832347ba58fed9cfa084" - }, - "pixel_values": { - "shape": [ - 1200, - 1536 - ], - "dtype": "torch.float32", - "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" - } - }, - "probabilities": [ - 0.07546718418598175, - 0.00034948240499943495, - 0.263406366109848, - 0.557631254196167, - 0.009013270027935505, - 0.01908109337091446, - 0.007019542157649994, - 0.016839005053043365, - 0.009013270027935505, - 0.0025823453906923532, - 0.004824455827474594, - 0.003315796609967947, - 0.002011132426559925, - 0.0022789116483181715, - 0.00619472423568368, - 0.0010764816543087363, - 0.0037572900764644146, - 0.0006529190577566624, - 0.002011132426559925, - 0.0012198134791105986, - 0.00044874430750496686, - 0.0005084939184598625, - 0.003315796609967947, - 0.0013822298496961594, - 0.0017748181708157063, - 0.004824455827474594 - ], - "latency_ms": 314.77690767496824 - }, - { - "name": "structured", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 469 - ], - "dtype": "torch.int64", - "sha256": "51435b8464d5ef7dde621ff5dd7679036480601f39496e693687a2b81d178553" - }, - "attention_mask": { - "shape": [ - 1, - 469 - ], - "dtype": "torch.int64", - "sha256": "75a539e8d5305e6bc6b6d4f53e3c5e06be4f04fcaa8bdb5995794b7cf09fe80f" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 469 - ], - "dtype": "torch.int64", - "sha256": "269da87e532542e6e885dfd9ac112e706ee7f033044955ba5020f6b844c86a0c" - }, - "pixel_values": { - "shape": [ - 1200, - 1536 - ], - "dtype": "torch.float32", - "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" - } - }, - "probabilities": [ - 0.07443060725927353, - 0.9067503809928894, - 0.01881900243461132 - ], - "latency_ms": 141.84184558689594 - }, - { - "name": "special-token", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 441 - ], - "dtype": "torch.int64", - "sha256": "6abf0a9290f3d2a19d5063d24e5c831eae8697c604e7206e7fcf83c4f1b013fe" - }, - "attention_mask": { - "shape": [ - 1, - 441 - ], - "dtype": "torch.int64", - "sha256": "07d34f72fa2eb8b18b38092dfb3bb5364429d5008739c6290d61fd68d500a2b0" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 441 - ], - "dtype": "torch.int64", - "sha256": "7ffc7201ce92882bf791a82175d36c9f7910e5bdba09d335cac9b8d6640b6caa" - }, - "pixel_values": { - "shape": [ - 1200, - 1536 - ], - "dtype": "torch.float32", - "sha256": "92648e27fcd15cac68708dbe53974f3cd64c4f5bcc32d17944d7cead68aa469c" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "d57d75cd100b84d70668fa90c17881ed8d1fcb7bb199a216e050a284b48dfe0e" - } - }, - "probabilities": [ - 0.531209409236908, - 0.4687906503677368 - ], - "latency_ms": 140.13662841171026 - }, - { - "name": "two-questions", - "question": "next", - "inputs": { - "input_ids": { - "shape": [ - 1, - 236 - ], - "dtype": "torch.int64", - "sha256": "21309638ff0c5ca8b7d1bf4b61905de3f31a216667ebc20fec9cdfaacdf08d48" - }, - "attention_mask": { - "shape": [ - 1, - 236 - ], - "dtype": "torch.int64", - "sha256": "1b489e733e23e18297cee9103f1b583499b76d29ab36a61129ac4fabc6dbd27a" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 236 - ], - "dtype": "torch.int64", - "sha256": "21b9904b99d4c8ade165eae791ba8439afbbe6ee838c32df37f14031ab51bb3d" - }, - "pixel_values": { - "shape": [ - 320, - 1536 - ], - "dtype": "torch.float32", - "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" - } - }, - "probabilities": [ - 0.9958575367927551, - 0.0005507932510226965, - 0.003591623157262802 - ], - "latency_ms": 114.18061796575785 - }, - { - "name": "two-questions", - "question": "second", - "inputs": { - "input_ids": { - "shape": [ - 1, - 215 - ], - "dtype": "torch.int64", - "sha256": "1bc665c3f5aa0134e368d1a9edf0e652ec604cf43e969d59b14f696a4cf5c9c3" - }, - "attention_mask": { - "shape": [ - 1, - 215 - ], - "dtype": "torch.int64", - "sha256": "bbdd8ad88f622ea9585a6b471f3ef6810a0c3374e43dbcb747e3077de4e6e674" - }, - "mm_token_type_ids": { - "shape": [ - 1, - 215 - ], - "dtype": "torch.int64", - "sha256": "6dc930bb14d93a028e6d2db398b391c4fe5af99184ec6625d38d2f7820e182f3" - }, - "pixel_values": { - "shape": [ - 320, - 1536 - ], - "dtype": "torch.float32", - "sha256": "8fd8d3e52f9c4d9fcc14ae0467e7d0642ce620e733705e6a77edd1f4e7940776" - }, - "image_grid_thw": { - "shape": [ - 1, - 3 - ], - "dtype": "torch.int64", - "sha256": "62ab45c5deaaea64b40e38c48f540fbdfb6235ee5d28cc2630dc82c526d25329" - } - }, - "probabilities": [ - 0.22270014882087708, - 0.7772998809814453 - ], - "latency_ms": 117.08385031670332 - } - ], - "reference_source": { - "path": "libs/cua-s1/python/src/cua_s1/four_b.py", - "sha256": "7ed1adfd92223bef7d533db7efbb4cbf468c4936c4380ae42aee12097e3b9ea7", - "revision": "0e75660ce4c2edda519e0c795fa3ad98abf4e76f" - }, - "artifact_verification_ms": 9541.830752044916, - "load_ms": 16820.161445997655, - "warmup_ms": 3665.197447873652, - "peak_allocated_bytes": 9655206912 -} \ No newline at end of file From 9093fd820e737a185aa72f2123d0f6e28b6f06ae Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Wed, 30 Sep 2026 00:35:46 +0800 Subject: [PATCH 25/26] Move Cua-S1 HTTP serving out of models and reuse upstream weight manifest --- .github/workflows/cua-s1-multimodal.yml | 6 +- README.md | 2 +- recipe/cua_s1/README.md | 14 ++- recipe/cua_s1/download_weights.py | 20 ++-- .../server.py => frontend/cua_s1.py} | 4 +- .../cua_s1/multimodal/THIRD_PARTY_NOTICES.md | 21 ---- src/models/cua_s1/multimodal/model.py | 12 ++- src/models/cua_s1/multimodal/protocol.py | 22 +++- .../cua_s1/multimodal/weights.lock.json | 102 ------------------ tests/cua_s1/test_download_weights.py | 83 ++++++++++++++ tests/cua_s1/test_model.py | 14 ++- tests/cua_s1/test_server.py | 2 +- 12 files changed, 160 insertions(+), 142 deletions(-) rename src/{models/cua_s1/multimodal/server.py => frontend/cua_s1.py} (97%) delete mode 100644 src/models/cua_s1/multimodal/THIRD_PARTY_NOTICES.md delete mode 100644 src/models/cua_s1/multimodal/weights.lock.json create mode 100644 tests/cua_s1/test_download_weights.py diff --git a/.github/workflows/cua-s1-multimodal.yml b/.github/workflows/cua-s1-multimodal.yml index 9329244..9d4fd7b 100644 --- a/.github/workflows/cua-s1-multimodal.yml +++ b/.github/workflows/cua-s1-multimodal.yml @@ -3,6 +3,7 @@ on: pull_request: paths: - 'src/models/cua_s1/multimodal/**' + - 'src/frontend/cua_s1.py' - 'tests/cua_s1/**' - 'recipe/cua_s1/**' - '.github/workflows/cua-s1-multimodal.yml' @@ -10,6 +11,7 @@ on: branches: [main] paths: - 'src/models/cua_s1/multimodal/**' + - 'src/frontend/cua_s1.py' - 'tests/cua_s1/**' - 'recipe/cua_s1/**' - '.github/workflows/cua-s1-multimodal.yml' @@ -26,5 +28,5 @@ jobs: python-version: '3.12' - run: python -m pip install Pillow==11.3.0 pytest==9.1.1 ruff==0.16.8 - run: PYTHONPATH=src python -m pytest tests/cua_s1 -q - - run: ruff check --isolated --select E4,E7,E9,F,I src/models/cua_s1/multimodal tests/cua_s1 recipe/cua_s1 - - run: ruff format --isolated --check src/models/cua_s1/multimodal tests/cua_s1 recipe/cua_s1 + - run: ruff check --isolated --select E4,E7,E9,F,I src/frontend/cua_s1.py src/models/cua_s1/multimodal tests/cua_s1 recipe/cua_s1 + - run: ruff format --isolated --check src/frontend/cua_s1.py src/models/cua_s1/multimodal tests/cua_s1 recipe/cua_s1 diff --git a/README.md b/README.md index 2cca0d9..17d41db 100644 --- a/README.md +++ b/README.md @@ -41,7 +41,7 @@ Implementation code lives under `src/`; recipes and documentation stay at the re | Directory | Responsibility | | --- | --- | -| [`src/frontend/`](src/frontend/) | Rust serving code and the small engine interface. | +| [`src/frontend/`](src/frontend/) | Rust serving code, Python worker adapters, and the small engine interface. | | [`src/models/`](src/models/) | Model implementations, one directory per model: preprocessing, batching, state, execution, and output processing. | | [`src/backends/cuda/`](src/backends/cuda/) | NVIDIA GPU operations and kernel integration. | | [`src/backends/metal/`](src/backends/metal/) | Apple GPU operations and kernel integration. | diff --git a/recipe/cua_s1/README.md b/recipe/cua_s1/README.md index 741a29e..753eef7 100644 --- a/recipe/cua_s1/README.md +++ b/recipe/cua_s1/README.md @@ -22,17 +22,23 @@ python3.12 -m venv .venv . .venv/bin/activate pip install -r recipe/cua_s1/requirements-multimodal.txt PYTHONPATH=src python recipe/cua_s1/download_weights.py --dest weights -PYTHONPATH=src python -m models.cua_s1.multimodal.server \ +PYTHONPATH=src python -m frontend.cua_s1 \ --base weights/Qwen3.5-4B \ --adapter weights/cua-s1-4b-0.2/multimodal ``` -`weights.lock.json` pins and checks every loaded artifact's size and SHA-256. +The downloader fetches the upstream manifest at the fixed reference revision, +checks its pinned SHA-256 and saves it as `weights/weights.lock.json`. The worker +reads this local manifest and checks every loaded artifact's size and SHA-256. +Keep the manifest next to the base checkpoint directory when moving weights. Extra files are rejected, except Hugging Face's `.cache` metadata, so another checkpoint cannot silently override verified shards. Downloads require roughly 9 GB plus cache/install space. Loading is offline after the download completes. Weights are not included in this repository. +The HTTP adapter lives in `src/frontend/cua_s1.py`; model execution stays in +`src/models/cua_s1/multimodal/`. + The worker binds to `127.0.0.1:8000` only after loading and a successful warmup. `GET /health` returns `{"status":"ready","modality":"multimodal"}`. One request runs at a time; concurrent requests return `503`. This is a loopback model worker, @@ -138,8 +144,8 @@ CPU-only validation: ```sh pip install Pillow==11.3.0 pytest==9.1.1 ruff==0.16.8 PYTHONPATH=src python -m pytest tests/cua_s1 -q -ruff check --select E4,E7,E9,F,I src/models/cua_s1/multimodal recipe/cua_s1/*.py tests/cua_s1 -ruff format --check src/models/cua_s1/multimodal recipe/cua_s1/*.py tests/cua_s1 +ruff check --select E4,E7,E9,F,I src/frontend/cua_s1.py src/models/cua_s1/multimodal recipe/cua_s1/*.py tests/cua_s1 +ruff format --check src/frontend/cua_s1.py src/models/cua_s1/multimodal recipe/cua_s1/*.py tests/cua_s1 ``` Metal, native CUDA kernels, text-adapter serving, batching, caching and training diff --git a/recipe/cua_s1/download_weights.py b/recipe/cua_s1/download_weights.py index 104b393..f1474bb 100644 --- a/recipe/cua_s1/download_weights.py +++ b/recipe/cua_s1/download_weights.py @@ -1,23 +1,30 @@ """Download the upstream-pinned artifacts and verify their checksums.""" import argparse -import json from pathlib import Path +from urllib.request import urlopen from huggingface_hub import snapshot_download -from models.cua_s1.multimodal.model import verify_weights +from models.cua_s1.multimodal.model import ( + REFERENCE_REVISION, + parse_weights_manifest, + verify_weights, +) def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--dest", type=Path, required=True) args = parser.parse_args() - lock = ( - Path(__file__).resolve().parents[2] - / "src/models/cua_s1/multimodal/weights.lock.json" + url = ( + f"https://raw.githubusercontent.com/trycua/cua/{REFERENCE_REVISION}/" + "libs/cua-s1/ci/weights.lock.json" ) - for artifact in json.loads(lock.read_text())["artifacts"]: + with urlopen(url, timeout=30) as response: + raw = response.read() + manifest = parse_weights_manifest(raw) + for artifact in manifest["artifacts"]: snapshot_download( repo_id=artifact["repo_id"], revision=artifact["revision"], @@ -25,6 +32,7 @@ def main(): allow_patterns=list(artifact["files"]), token=False, ) + (args.dest / "weights.lock.json").write_bytes(raw) verify_weights(args.dest / "Qwen3.5-4B", args.dest / "cua-s1-4b-0.2/multimodal") print("Pinned base and multimodal adapter checksums verified.") diff --git a/src/models/cua_s1/multimodal/server.py b/src/frontend/cua_s1.py similarity index 97% rename from src/models/cua_s1/multimodal/server.py rename to src/frontend/cua_s1.py index c414bc9..bde882c 100644 --- a/src/models/cua_s1/multimodal/server.py +++ b/src/frontend/cua_s1.py @@ -9,7 +9,7 @@ import threading from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer -from .protocol import ( +from models.cua_s1.multimodal.protocol import ( MAX_BODY, InvalidRequest, MalformedJSON, @@ -107,7 +107,7 @@ def do_POST(self): def main(): - from .model import MultimodalEngine + from models.cua_s1.multimodal.model import MultimodalEngine p = argparse.ArgumentParser(description=__doc__) p.add_argument( diff --git a/src/models/cua_s1/multimodal/THIRD_PARTY_NOTICES.md b/src/models/cua_s1/multimodal/THIRD_PARTY_NOTICES.md deleted file mode 100644 index b8b198c..0000000 --- a/src/models/cua_s1/multimodal/THIRD_PARTY_NOTICES.md +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2025 Cua AI, Inc. - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/src/models/cua_s1/multimodal/model.py b/src/models/cua_s1/multimodal/model.py index db55070..e3655de 100644 --- a/src/models/cua_s1/multimodal/model.py +++ b/src/models/cua_s1/multimodal/model.py @@ -12,6 +12,9 @@ BASE_REVISION = "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a" ADAPTER_REVISION = "16818868b0cc7813808aae4e87b417657046ab79" IDENTITY = f"cua-ai/cua-s1-4b-0.2@{ADAPTER_REVISION}:multimodal" +WEIGHTS_MANIFEST_SHA256 = ( + "9820bd232c5762f114e19680c0f8203d7e1faaf8a60c196cfe01964d6d8a6c09" +) MAX_TOKENS = 4096 @@ -47,9 +50,16 @@ def validate_adapter_config(config: dict): raise ValueError("expected the pinned 0.2 multimodal LoRA adapter") +def parse_weights_manifest(raw: bytes) -> dict: + """Accept only the manifest from the pinned upstream reference commit.""" + if hashlib.sha256(raw).hexdigest() != WEIGHTS_MANIFEST_SHA256: + raise ValueError("upstream weights manifest checksum mismatch") + return json.loads(raw) + + def verify_weights(base: Path, adapter: Path): """Check local artifacts before assigning the pinned identity to responses.""" - lock = json.loads(Path(__file__).with_name("weights.lock.json").read_text()) + lock = parse_weights_manifest((base.parent / "weights.lock.json").read_bytes()) allowed = {base: set(), adapter: set()} for artifact in lock["artifacts"]: for name, expected in artifact["files"].items(): diff --git a/src/models/cua_s1/multimodal/protocol.py b/src/models/cua_s1/multimodal/protocol.py index edd207d..4346257 100644 --- a/src/models/cua_s1/multimodal/protocol.py +++ b/src/models/cua_s1/multimodal/protocol.py @@ -21,7 +21,27 @@ MAX_TEXT = 16384 # Prompt and letter layout follow trycua/cua at 0e75660ce4c2edda519e0c795fa3ad98abf4e76f. -# See THIRD_PARTY_NOTICES.md for the upstream MIT notice. +# MIT License +# +# Copyright (c) 2025 Cua AI, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. SYSTEM_PROMPT = ( "You are a one-pass computer-use decision model. You are shown the " "current state of a screen and a fixed, closed list of candidate " diff --git a/src/models/cua_s1/multimodal/weights.lock.json b/src/models/cua_s1/multimodal/weights.lock.json deleted file mode 100644 index dfb9748..0000000 --- a/src/models/cua_s1/multimodal/weights.lock.json +++ /dev/null @@ -1,102 +0,0 @@ -{ - "schema": "cua-s1/weights-lock/v1", - "description": "Pinned public Hugging Face artifacts for the weights-backed Cua-S1-4B smoke. Every listed file is downloaded at the pinned revision and verified by size and SHA-256; keep in sync with libs/cua-s1/README.md.", - "artifacts": [ - { - "name": "Qwen3.5-4B", - "repo_id": "Qwen/Qwen3.5-4B", - "revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", - "role": "base", - "files": { - ".gitattributes": { - "size": 1570, - "sha256": "34448b82c17d60fec9b65b1f093c115ddbaadc04beb1b0140b6bfed2e012a930" - }, - "LICENSE": { - "size": 11544, - "sha256": "bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a" - }, - "README.md": { - "size": 77661, - "sha256": "1406be1b6b8fd8a6545870da516912804756593628a1d0fb0a7965211e82a7bb" - }, - "chat_template.jinja": { - "size": 7756, - "sha256": "a4aee8afcf2e0711942cf848899be66016f8d14a889ff9ede07bca099c28f715" - }, - "config.json": { - "size": 3161, - "sha256": "ddc63e1c717afa86c865bb5e01313d89d72bb53b97ad4a8a03ba8510c0621670" - }, - "merges.txt": { - "size": 3353259, - "sha256": "a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d" - }, - "model.safetensors-00001-of-00002.safetensors": { - "size": 5329398688, - "sha256": "26a93f066e1916adb13453dae5a0c707c0fbc71299ed98779571a907b8e74c61" - }, - "model.safetensors-00002-of-00002.safetensors": { - "size": 3990429408, - "sha256": "cb544bd9bfae93dc59b0f22b292f5933573854a7f9b97835c67060d7d910e188" - }, - "model.safetensors.index.json": { - "size": 76196, - "sha256": "cf3f798ee02ba45f9622aa8892a47369ab667d0afbf154ee7c2212de42e6302d" - }, - "preprocessor_config.json": { - "size": 390, - "sha256": "27225450ac9c6529872ee1924fcb0962ff5634834f817040f444118116f4e516" - }, - "tokenizer.json": { - "size": 12807982, - "sha256": "5f9e4d4901a92b997e463c1f46055088b6cca5ca61a6522d1b9f64c4bb81cb42" - }, - "tokenizer_config.json": { - "size": 16710, - "sha256": "316230d6a809701f4db5ea8f8fc862bc3a6f3229c937c174e674ff3ca0a64ac8" - }, - "video_preprocessor_config.json": { - "size": 385, - "sha256": "7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13" - }, - "vocab.json": { - "size": 6722759, - "sha256": "ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003" - } - } - }, - { - "name": "cua-s1-4b-0.2", - "repo_id": "cua-ai/cua-s1-4b-0.2", - "revision": "16818868b0cc7813808aae4e87b417657046ab79", - "role": "adapter", - "files": { - ".gitattributes": { - "size": 1519, - "sha256": "11ad7efa24975ee4b0c3c3a38ed18737f0658a5f75a0a96787b576a78a023361" - }, - "README.md": { - "size": 1134, - "sha256": "0e89cb4aea205e08c13f8af7fbfdfd0854ba0f6c57602071238771d0e1f8c7cd" - }, - "multimodal/adapter_config.json": { - "size": 1129, - "sha256": "f80edac43dd7605317ae8189613c75d13a029fa5d8a4870c04f1ba7097a8fab5" - }, - "multimodal/adapter_model.safetensors": { - "size": 101665112, - "sha256": "38ecd5a9191a436c1739db29104517f0aff4c70d0736d9cd810d3d49cfd652ea" - }, - "text/adapter_config.json": { - "size": 1091, - "sha256": "c246fce1fe1d44160ae5f246f9881dfeabb4fcd67fe4a777cef10a1dbcf16540" - }, - "text/adapter_model.safetensors": { - "size": 84968408, - "sha256": "9b59c5aed96171a50b26526613766bbf44347a5c7af70f81efe6bcc6e9dbfb0e" - } - } - } - ] -} diff --git a/tests/cua_s1/test_download_weights.py b/tests/cua_s1/test_download_weights.py new file mode 100644 index 0000000..5fb9939 --- /dev/null +++ b/tests/cua_s1/test_download_weights.py @@ -0,0 +1,83 @@ +"""Download setup uses the upstream manifest without checking a copy into source.""" + +import importlib.util +import io +import json +import sys +from pathlib import Path +from types import SimpleNamespace + +import pytest + + +@pytest.mark.parametrize("corrupt", [False, True]) +def test_manifest_is_verified_before_downloading_weights( + tmp_path, monkeypatch, corrupt +): + from models.cua_s1.multimodal import model + + raw = json.dumps( + { + "artifacts": [ + { + "repo_id": "test/base", + "revision": "fixed", + "name": "Qwen3.5-4B", + "files": {"config.json": {}}, + } + ] + } + ).encode() + import hashlib + + monkeypatch.setattr( + model, "WEIGHTS_MANIFEST_SHA256", hashlib.sha256(raw).hexdigest() + ) + downloads = [] + + def download(**kwargs): + downloads.append(kwargs) + kwargs["local_dir"].mkdir(parents=True) + + monkeypatch.setitem( + sys.modules, "huggingface_hub", SimpleNamespace(snapshot_download=download) + ) + path = Path(__file__).resolve().parents[2] / "recipe/cua_s1/download_weights.py" + spec = importlib.util.spec_from_file_location("download_weights_test", path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + payload = raw + b" " if corrupt else raw + urls = [] + + def fetch(url, timeout): + urls.append(url) + assert timeout == 30 + return io.BytesIO(payload) + + monkeypatch.setattr(module, "urlopen", fetch) + verified = [] + + def verify(base, adapter): + assert (base.parent / "weights.lock.json").read_bytes() == raw + verified.append((base, adapter)) + + monkeypatch.setattr(module, "verify_weights", verify) + dest = tmp_path / "weights" + monkeypatch.setattr(sys, "argv", [str(path), "--dest", str(dest)]) + if corrupt: + with pytest.raises(ValueError, match="manifest checksum"): + module.main() + assert not downloads and not verified and not dest.exists() + else: + module.main() + assert downloads == [ + { + "repo_id": "test/base", + "revision": "fixed", + "local_dir": dest / "Qwen3.5-4B", + "allow_patterns": ["config.json"], + "token": False, + } + ] + assert verified == [(dest / "Qwen3.5-4B", dest / "cua-s1-4b-0.2/multimodal")] + assert model.REFERENCE_REVISION in urls[0] diff --git a/tests/cua_s1/test_model.py b/tests/cua_s1/test_model.py index 228e3ac..d37728f 100644 --- a/tests/cua_s1/test_model.py +++ b/tests/cua_s1/test_model.py @@ -84,7 +84,11 @@ def test_unlisted_model_files_cannot_override_verified_shards(tmp_path, monkeypa } ) ) - monkeypatch.setattr(model, "__file__", str(tmp_path / "model.py")) + monkeypatch.setattr( + model, + "WEIGHTS_MANIFEST_SHA256", + hashlib.sha256(manifest.read_bytes()).hexdigest(), + ) model.verify_weights(base, adapter) (base / "model.safetensors").write_bytes(b"override") with pytest.raises(ValueError, match="unlisted"): @@ -110,3 +114,11 @@ def prepare(image, question): with pytest.raises(InvalidRequest, match="4096"): engine.predict(Request(None, (first, second))) assert forwarded == [] + + +def test_weights_manifest_must_match_pinned_upstream_digest(tmp_path): + from models.cua_s1.multimodal.model import verify_weights + + (tmp_path / "weights.lock.json").write_text('{"artifacts": []}') + with pytest.raises(ValueError, match="manifest checksum"): + verify_weights(tmp_path / "base", tmp_path / "adapter") diff --git a/tests/cua_s1/test_server.py b/tests/cua_s1/test_server.py index 6238598..50bd2cb 100644 --- a/tests/cua_s1/test_server.py +++ b/tests/cua_s1/test_server.py @@ -6,8 +6,8 @@ import pytest from test_protocol import image_url, request +from frontend.cua_s1 import Handler, WorkerServer from models.cua_s1.multimodal.protocol import MAX_BODY -from models.cua_s1.multimodal.server import Handler, WorkerServer class Engine: From 934e1ad1dca8f2f447c935d267e01b9216ccf337 Mon Sep 17 00:00:00 2001 From: levius <2114377220@qq.com> Date: Wed, 30 Sep 2026 09:08:53 +0800 Subject: [PATCH 26/26] chore: limit PR to multimodal runtime code Remove supplemental tests, recipe tools, documentation, CI, and configuration changes from the PR diff. Runtime Python source and inline third-party notice are unchanged. Validation uses the pre-cleanup test/tool snapshot outside the checkout. --- .github/workflows/cua-s1-multimodal.yml | 32 --- .gitignore | 13 +- README.md | 12 +- recipe/cua_s1/README.md | 153 ---------- recipe/cua_s1/check_frontend.py | 75 ----- recipe/cua_s1/download_weights.py | 41 --- recipe/cua_s1/evaluate_multimodal.py | 322 ---------------------- recipe/cua_s1/make_example.py | 71 ----- recipe/cua_s1/requirements-multimodal.txt | 11 - src/models/cua_s1/README.md | 4 +- tests/cua_s1/test_download_weights.py | 83 ------ tests/cua_s1/test_evaluation.py | 65 ----- tests/cua_s1/test_model.py | 124 --------- tests/cua_s1/test_protocol.py | 172 ------------ tests/cua_s1/test_server.py | 204 -------------- 15 files changed, 9 insertions(+), 1373 deletions(-) delete mode 100644 .github/workflows/cua-s1-multimodal.yml delete mode 100644 recipe/cua_s1/README.md delete mode 100644 recipe/cua_s1/check_frontend.py delete mode 100644 recipe/cua_s1/download_weights.py delete mode 100644 recipe/cua_s1/evaluate_multimodal.py delete mode 100644 recipe/cua_s1/make_example.py delete mode 100644 recipe/cua_s1/requirements-multimodal.txt delete mode 100644 tests/cua_s1/test_download_weights.py delete mode 100644 tests/cua_s1/test_evaluation.py delete mode 100644 tests/cua_s1/test_model.py delete mode 100644 tests/cua_s1/test_protocol.py delete mode 100644 tests/cua_s1/test_server.py diff --git a/.github/workflows/cua-s1-multimodal.yml b/.github/workflows/cua-s1-multimodal.yml deleted file mode 100644 index 9d4fd7b..0000000 --- a/.github/workflows/cua-s1-multimodal.yml +++ /dev/null @@ -1,32 +0,0 @@ -name: Cua-S1 multimodal CPU checks -on: - pull_request: - paths: - - 'src/models/cua_s1/multimodal/**' - - 'src/frontend/cua_s1.py' - - 'tests/cua_s1/**' - - 'recipe/cua_s1/**' - - '.github/workflows/cua-s1-multimodal.yml' - push: - branches: [main] - paths: - - 'src/models/cua_s1/multimodal/**' - - 'src/frontend/cua_s1.py' - - 'tests/cua_s1/**' - - 'recipe/cua_s1/**' - - '.github/workflows/cua-s1-multimodal.yml' -permissions: - contents: read -jobs: - cpu: - runs-on: ubuntu-latest - timeout-minutes: 10 - steps: - - uses: actions/checkout@v4 - - uses: actions/setup-python@v5 - with: - python-version: '3.12' - - run: python -m pip install Pillow==11.3.0 pytest==9.1.1 ruff==0.16.8 - - run: PYTHONPATH=src python -m pytest tests/cua_s1 -q - - run: ruff check --isolated --select E4,E7,E9,F,I src/frontend/cua_s1.py src/models/cua_s1/multimodal tests/cua_s1 recipe/cua_s1 - - run: ruff format --isolated --check src/frontend/cua_s1.py src/models/cua_s1/multimodal tests/cua_s1 recipe/cua_s1 diff --git a/.gitignore b/.gitignore index b42bbc8..3857937 100644 --- a/.gitignore +++ b/.gitignore @@ -20,16 +20,7 @@ target # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ -# Python workers and local model artifacts -__pycache__/ -.pytest_cache/ -.ruff_cache/ +# Local Python worker environment .venv/ -weights/ - -# macOS metadata +__pycache__/ .DS_Store - -# Local experiment outputs and assistant planning notes -/recipe/cua_s1/experiments/ -/docs/superpowers/ diff --git a/README.md b/README.md index 17d41db..76944aa 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ A community-maintained inference engine for prefill-only System1-Omni models, designed around a Rust frontend, model-owned execution, and high-performance CUDA and Metal backends. -The Rust frontend forwards requests to a separately running model worker. The Cua-S1 multimodal worker has been validated on CUDA through Transformers and PEFT; native GPU backends remain planned. +The Rust frontend forwards requests to a separately running model worker. In-repository model engines and GPU backends are not implemented yet. ## Run the frontend @@ -17,8 +17,7 @@ OMNI_JEV_BACKEND_URL=http://127.0.0.1:8000 \ Start the worker separately. See the [frontend documentation](src/frontend/README.md) for the HTTP interface and configuration, or the [Laya recipe](recipe/laya/README.md) -for a CPU text worker and response checks. The [Cua-S1 recipe](recipe/cua_s1/README.md) -provides a CUDA worker for screenshot-conditioned choices. +for a CPU text worker and response checks. ## Architecture @@ -41,23 +40,22 @@ Implementation code lives under `src/`; recipes and documentation stay at the re | Directory | Responsibility | | --- | --- | -| [`src/frontend/`](src/frontend/) | Rust serving code, Python worker adapters, and the small engine interface. | +| [`src/frontend/`](src/frontend/) | Rust serving code and the small engine interface. | | [`src/models/`](src/models/) | Model implementations, one directory per model: preprocessing, batching, state, execution, and output processing. | | [`src/backends/cuda/`](src/backends/cuda/) | NVIDIA GPU operations and kernel integration. | | [`src/backends/metal/`](src/backends/metal/) | Apple GPU operations and kernel integration. | | [`recipe/`](recipe/) | Model setup instructions, launch commands, configuration examples, and example requests. | | [`docs/`](docs/) | Project documentation and architecture assets. | -The frontend is a Cargo workspace member. Model and backend directories document ownership, with implementations added incrementally; they do not prescribe process boundaries. +The frontend is a Cargo workspace member. Model and backend directories currently document planned work; they do not prescribe process boundaries. ## Supported models -Validated coverage is listed by modality and execution path: +LAYA can run as an external Python worker for text requests. Its in-repository model engine is still planned: | Model | Status | | --- | --- | | LAYA | [External worker](recipe/laya/README.md); model engine planned | -| [Cua-S1 4B 0.2](recipe/cua_s1/README.md) | Multimodal screenshot choices via Transformers/PEFT on RTX 4090 CUDA; [parity and measurements](https://github.com/Levius-Fubuki/system1-omni/blob/683d470669f19d5e9530cd8233727a0d4f1f8d29/recipe/cua_s1/experiments/README.md). Text serving, native CUDA kernels and Metal deferred. | CUDA and Metal coverage will be documented per model as implementations are added and validated. diff --git a/recipe/cua_s1/README.md b/recipe/cua_s1/README.md deleted file mode 100644 index 753eef7..0000000 --- a/recipe/cua_s1/README.md +++ /dev/null @@ -1,153 +0,0 @@ -# Cua-S1 0.2 multimodal CUDA worker - -This recipe adds screenshot decisions using the multimodal adapter discussed in -[#10](https://github.com/ThinkFlowLab/system1-omni/issues/10). It loads Transformers -and PEFT directly. Upstream `FourBModel` is used only as an independent parity -oracle. The worker owns image decoding, the processor/chat template, vision and -language LoRA loading, and the candidate-letter probability readout. - -The text mapping and pinned revisions follow -[PR #11](https://github.com/ThinkFlowLab/system1-omni/pull/11). The image `state` -format below is this PR's proposed extension. A separately launched multimodal -worker uses the same request model name; deployment routing selects its modality. - -## Setup - -Run from this repository's root on Linux with an NVIDIA GPU. The measured CUDA -wheel, driver, GPU memory and results are recorded in [experiments](https://github.com/Levius-Fubuki/system1-omni/blob/683d470669f19d5e9530cd8233727a0d4f1f8d29/recipe/cua_s1/experiments/README.md). -Python 3.12 is required by the pinned environment. - -```sh -python3.12 -m venv .venv -. .venv/bin/activate -pip install -r recipe/cua_s1/requirements-multimodal.txt -PYTHONPATH=src python recipe/cua_s1/download_weights.py --dest weights -PYTHONPATH=src python -m frontend.cua_s1 \ - --base weights/Qwen3.5-4B \ - --adapter weights/cua-s1-4b-0.2/multimodal -``` - -The downloader fetches the upstream manifest at the fixed reference revision, -checks its pinned SHA-256 and saves it as `weights/weights.lock.json`. The worker -reads this local manifest and checks every loaded artifact's size and SHA-256. -Keep the manifest next to the base checkpoint directory when moving weights. -Extra files are rejected, except Hugging Face's `.cache` metadata, so another -checkpoint cannot silently override verified shards. Downloads require roughly -9 GB plus cache/install space. Loading is offline after the download completes. -Weights are not included in this repository. - -The HTTP adapter lives in `src/frontend/cua_s1.py`; model execution stays in -`src/models/cua_s1/multimodal/`. - -The worker binds to `127.0.0.1:8000` only after loading and a successful warmup. -`GET /health` returns `{"status":"ready","modality":"multimodal"}`. One request -runs at a time; concurrent requests return `503`. This is a loopback model worker, -with the Rust frontend and an ingress responsible for public serving. - -To use the Rust frontend included in this repository: - -```sh -cargo build --release --locked -OMNI_JEV_BIND=127.0.0.1:8080 \ -OMNI_JEV_BACKEND_URL=http://127.0.0.1:8000 ./target/release/omni-jev -``` - -## Request and response - -Generate a self-contained example with a synthetic settings screenshot: - -```sh -python recipe/cua_s1/make_example.py --output /tmp/cua-example.json -curl -sS http://127.0.0.1:8000/v1/systemone \ - -H 'Content-Type: application/json' --data-binary @/tmp/cua-example.json -``` - -Replace the port with `8080` to send the same request through the frontend. -The request shape is: - -```json -{ - "model": "cua-s1-4b-0.2", - "state": {"image": "data:image/png;base64,"}, - "questions": { - "next": { - "type": "choice", - "instructions": "Save the changes", - "criteria": {"save": "Save changes", "cancel": "Cancel"} - } - } -} -``` - -- `state` contains exactly one inline PNG or JPEG data URL. Images are decoded to - RGB. Local filenames, remote URLs, video, animation and mixed text/image state - are unsupported. -- There are 1–8 questions and 1–26 options per question. Option order assigns - letters A–Z. Labels are strings, objects, arrays or `null` (which uses the key). - Structured values use Python `json.dumps(..., ensure_ascii=False)` followed by - the upstream chooser's label escaping. Instructions accept strings, objects - or arrays and must be present; an empty string or `null` omits the goal block. -- Limits: 8 MiB body, 4 MiB decoded image, 2048 pixels per side, 1,048,576 pixels - total, at most 200:1 aspect ratio in either orientation, 16,384 characters per - question and 4096 processed tokens per question. - Every question is validated/preprocessed before any forward pass begins. -- `<|image_pad|>`, `<|video_pad|>`, `<|vision_start|>` and `<|vision_end|>` are - rejected in user text because the processor interprets them as media controls. - Other special-token spellings retain upstream tokenization behavior. -- Malformed JSON (including duplicate keys, non-finite numbers, invalid UTF-8, - lone surrogates and non-object bodies) returns `400`. Well-formed unsupported - inputs, missing `instructions`, unsupported models and `score`/`noul` questions - return `422`. Error bodies use `{"detail": ""}`. Oversized bodies - return `413`; chunked uploads return `411`. Send `Content-Length` and `Content-Type: application/json`. - -Each answer has `type`, `choice`, `probabilities` and `confidence`. The readout -uses the last position's candidate-letter logits, casts to fp32 and applies -softmax over those letters only. There is no decode. Ties select the earliest -option; confidence is `1 - H(p)/ln(n)`, or 1 for one option. Each question has a -separate forward pass over the same screenshot. Usage sums processed input tokens -and reports zero output tokens. - -Response identity: -`cua-ai/cua-s1-4b-0.2@16818868b0cc7813808aae4e87b417657046ab79:multimodal`. -The base is BF16; PEFT's rank-16, alpha-32 adapter remains unmerged with fp32 LoRA -branches, including 50 vision projection modules (178 total adapted modules). - -## Reproduce correctness and profiling - -```sh -git clone https://github.com/trycua/cua.git /tmp/cua-reference -git -C /tmp/cua-reference checkout 0e75660ce4c2edda519e0c795fa3ad98abf4e76f -for mode in reference candidate benchmark; do - PYTHONPATH=src python recipe/cua_s1/evaluate_multimodal.py \ - --weights weights --reference /tmp/cua-reference \ - --output /tmp/cua-evidence --mode "$mode" -done -``` - -The evaluator hashes the pinned `four_b.py` before importing it and checks report -provenance/environment before comparison. Reference and candidate are separate -processes to avoid keeping two models in GPU memory. Eight synthetic requests -(nine question forwards) cover two resolutions, PNG/JPEG, 1/26 candidates, -structured/Unicode labels, special-token text and multiple questions. It requires -identical processor tensor shapes/dtypes/hashes and identical fp32 candidate -probabilities; numerical tolerance is zero. These are integration/parity fixtures, -not an evaluation of GUI task success. - -Benchmark mode records two runs of 50 serial requests after five warmups on the -640×480 fixture, with synchronized end-to-end engine latency, p50/p95, serial -throughput, allocated/reserved GPU peaks and a separate operator profile. Load -and warmup are recorded separately; candidate load time includes artifact hash -verification. See the experiment report for measured scope and limitations. - -CPU-only validation: - -```sh -pip install Pillow==11.3.0 pytest==9.1.1 ruff==0.16.8 -PYTHONPATH=src python -m pytest tests/cua_s1 -q -ruff check --select E4,E7,E9,F,I src/frontend/cua_s1.py src/models/cua_s1/multimodal recipe/cua_s1/*.py tests/cua_s1 -ruff format --check src/frontend/cua_s1.py src/models/cua_s1/multimodal recipe/cua_s1/*.py tests/cua_s1 -``` - -Metal, native CUDA kernels, text-adapter serving, batching, caching and training -are outside this worker's scope. This implementation does not import or modify -another contributor's text engine. diff --git a/recipe/cua_s1/check_frontend.py b/recipe/cua_s1/check_frontend.py deleted file mode 100644 index 37fe0a0..0000000 --- a/recipe/cua_s1/check_frontend.py +++ /dev/null @@ -1,75 +0,0 @@ -"""Compare HTTP response status, content type and bytes through Rust and directly.""" - -import argparse -import hashlib -import json -import urllib.error -import urllib.request -from pathlib import Path - - -def exchange(base, route, body=None): - request = urllib.request.Request( - base.rstrip("/") + route, - data=body, - headers={"Content-Type": "application/json"}, - ) - try: - response = urllib.request.urlopen(request, timeout=60) - except urllib.error.HTTPError as exc: - response = exc - with response: - return response.status, response.headers.get("Content-Type"), response.read() - - -def main(): - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--worker", default="http://127.0.0.1:8000") - parser.add_argument("--frontend", default="http://127.0.0.1:8080") - parser.add_argument("--fixtures", type=Path, required=True) - parser.add_argument("--output", type=Path, required=True) - args = parser.parse_args() - fixtures = sorted(args.fixtures.glob("*.json")) - if not fixtures: - raise ValueError("at least one valid fixture is required") - checks = [("health", "/health", None)] - checks += [(p.stem, "/v1/systemone", p.read_bytes()) for p in fixtures] - checks += [ - ("invalid", "/v1/systemone", b"{}"), - ("duplicate", "/v1/systemone", b'{"model":1,"model":2}'), - ] - missing = json.loads(fixtures[0].read_bytes()) - next(iter(missing["questions"].values())).pop("instructions") - checks.append( - ("missing-instructions", "/v1/systemone", json.dumps(missing).encode()) - ) - report = [] - for name, route, body in checks: - direct = exchange(args.worker, route, body) - proxied = exchange(args.frontend, route, body) - assert direct == proxied, f"frontend changed response: {name}" - expected_status = { - "invalid": 422, - "duplicate": 400, - "missing-instructions": 422, - }.get(name, 200) - assert direct[0] == expected_status, f"unexpected status: {name}: {direct[0]}" - if expected_status >= 400: - assert set(json.loads(direct[2])) == {"detail"}, ( - f"wrong error envelope: {name}" - ) - report.append( - { - "name": name, - "status": direct[0], - "content_type": direct[1], - "body_sha256": hashlib.sha256(direct[2]).hexdigest(), - "identical": True, - } - ) - print(f"{name}: HTTP {direct[0]}, identical response", flush=True) - args.output.write_text(json.dumps(report, indent=2)) - - -if __name__ == "__main__": - main() diff --git a/recipe/cua_s1/download_weights.py b/recipe/cua_s1/download_weights.py deleted file mode 100644 index f1474bb..0000000 --- a/recipe/cua_s1/download_weights.py +++ /dev/null @@ -1,41 +0,0 @@ -"""Download the upstream-pinned artifacts and verify their checksums.""" - -import argparse -from pathlib import Path -from urllib.request import urlopen - -from huggingface_hub import snapshot_download - -from models.cua_s1.multimodal.model import ( - REFERENCE_REVISION, - parse_weights_manifest, - verify_weights, -) - - -def main(): - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--dest", type=Path, required=True) - args = parser.parse_args() - url = ( - f"https://raw.githubusercontent.com/trycua/cua/{REFERENCE_REVISION}/" - "libs/cua-s1/ci/weights.lock.json" - ) - with urlopen(url, timeout=30) as response: - raw = response.read() - manifest = parse_weights_manifest(raw) - for artifact in manifest["artifacts"]: - snapshot_download( - repo_id=artifact["repo_id"], - revision=artifact["revision"], - local_dir=args.dest / artifact["name"], - allow_patterns=list(artifact["files"]), - token=False, - ) - (args.dest / "weights.lock.json").write_bytes(raw) - verify_weights(args.dest / "Qwen3.5-4B", args.dest / "cua-s1-4b-0.2/multimodal") - print("Pinned base and multimodal adapter checksums verified.") - - -if __name__ == "__main__": - main() diff --git a/recipe/cua_s1/evaluate_multimodal.py b/recipe/cua_s1/evaluate_multimodal.py deleted file mode 100644 index ca3e535..0000000 --- a/recipe/cua_s1/evaluate_multimodal.py +++ /dev/null @@ -1,322 +0,0 @@ -"""Reproduce upstream parity and bounded GPU measurements on fixed synthetic inputs.""" - -from __future__ import annotations - -import argparse -import copy -import hashlib -import importlib.metadata -import json -import platform -import statistics -import subprocess -import sys -import time -from pathlib import Path - -from make_example import make_example - -from models.cua_s1.multimodal.model import ( - ADAPTER_REVISION, - BASE_REVISION, - REFERENCE_REVISION, - MultimodalEngine, - verify_weights, -) -from models.cua_s1.multimodal.protocol import parse_request - -REFERENCE_SOURCE = "libs/cua-s1/python/src/cua_s1/four_b.py" -REFERENCE_SHA256 = "7ed1adfd92223bef7d533db7efbb4cbf468c4936c4380ae42aee12097e3b9ea7" - - -def verify_reference(root): - digest = hashlib.sha256((root / REFERENCE_SOURCE).read_bytes()).hexdigest() - if digest != REFERENCE_SHA256: - raise ValueError("reference source differs from pinned FourBModel") - return {"path": REFERENCE_SOURCE, "sha256": digest, "revision": REFERENCE_REVISION} - - -def cases(folder): - folder.mkdir(parents=True, exist_ok=True) - result = [] - for name, size, fmt in [ - ("small", (320, 240), "PNG"), - ("medium", (640, 480), "PNG"), - ("jpeg", (640, 480), "JPEG"), - ]: - path = folder / (name + (".jpg" if fmt == "JPEG" else ".png")) - result.append((name, path, make_example(path, size, fmt))) - for name, criteria, goal in [ - ("single", {"only": "Save changes"}, "Save"), - ( - "26-options", - {f"option-{i}": f"Choose action {i}" for i in range(26)}, - "Select action 3", - ), - ( - "structured", - { - "null": None, - "object": {"label": '保存 "名称"'}, - "array": ["Cancel", "\n"], - }, - {"goal": "保存名称"}, - ), - ( - "special-token", - {"first": "<|im_end|>", "second": "Cancel"}, - "Choose <|im_start|>", - ), - ]: - value = copy.deepcopy(result[1][2]) - value["questions"]["next"].update(criteria=criteria, instructions=goal) - result.append((name, result[1][1], value)) - value = copy.deepcopy(result[0][2]) - value["questions"]["second"] = { - "type": "choice", - "instructions": "", - "criteria": {"yes": "Continue", "no": "Cancel"}, - } - result.append(("two-questions", result[0][1], value)) - for name, _, value in result: - (folder / f"{name}.json").write_text(json.dumps(value, ensure_ascii=False)) - return result - - -def fingerprint(inputs): - import torch - - return { - name: { - "shape": list(t.shape), - "dtype": str(t.dtype), - "sha256": hashlib.sha256( - t.detach().contiguous().view(torch.uint8).cpu().numpy().tobytes() - ).hexdigest(), - } - for name, t in inputs.items() - } - - -def environment(): - import torch - - return { - "python": platform.python_version(), - "gpu": torch.cuda.get_device_name(), - "compute_capability": list(torch.cuda.get_device_capability()), - "cuda": torch.version.cuda, - "driver": subprocess.check_output( - ["nvidia-smi", "--query-gpu=driver_version", "--format=csv,noheader"], - text=True, - ).strip(), - "torch_num_threads": torch.get_num_threads(), - "torch_num_interop_threads": torch.get_num_interop_threads(), - "packages": { - p: importlib.metadata.version(p) - for p in [ - "torch", - "torchvision", - "transformers", - "peft", - "pillow", - "safetensors", - "triton", - ] - }, - "reference_revision": REFERENCE_REVISION, - "base_revision": BASE_REVISION, - "adapter_revision": ADAPTER_REVISION, - "dtype": "bfloat16", - "adapter_merged": False, - } - - -def measure(call): - import torch - - torch.cuda.synchronize() - start = time.perf_counter() - result = call() - torch.cuda.synchronize() - return result, (time.perf_counter() - start) * 1000 - - -def quantiles(values): - ordered = sorted(values) - return { - "p50_ms": statistics.median(values), - "p95_ms": ordered[max(0, __import__("math").ceil(0.95 * len(values)) - 1)], - } - - -def main(): - import torch - - p = argparse.ArgumentParser(description=__doc__) - p.add_argument("--weights", type=Path, required=True) - p.add_argument( - "--reference", type=Path, required=True, help="checkout of pinned trycua/cua" - ) - p.add_argument("--output", type=Path, required=True) - p.add_argument( - "--mode", choices=["reference", "candidate", "benchmark"], required=True - ) - args = p.parse_args() - args.output.mkdir(parents=True, exist_ok=True) - base = str(args.weights / "Qwen3.5-4B") - adapter = str(args.weights / "cua-s1-4b-0.2/multimodal") - fixture_set = cases(args.output / "fixtures") - report = {"environment": environment(), "mode": args.mode, "cases": []} - report["reference_source"] = verify_reference(args.reference) - if args.mode == "reference": - _, report["artifact_verification_ms"] = measure( - lambda: verify_weights(Path(base), Path(adapter)) - ) - sys.path.insert(0, str(args.reference / "libs/cua-s1/python/src")) - from cua_s1.four_b import FourBModel, Option, assign_letters, build_prompt - - model = FourBModel( - base_model=base, lora_adapter_path=adapter, modality="multimodal" - ) - _, report["load_ms"] = measure(model.load) - first = True - for name, path, value in fixture_set: - request = parse_request(value) - for q in request.questions: - options = [ - Option(element_id=k, role="Decision", label=v, action="select") - for k, v in zip(q.keys, q.labels) - ] - messages = build_prompt( - assign_letters(options), - app="Cua Driver", - task_family="closed-candidate decision", - screenshot=path, - modality="multimodal", - goal=q.goal, - ) - text = model._processor.apply_chat_template( - messages, tokenize=False, add_generation_prompt=True - ) - inputs = model._processor( - text=[text], images=[request.image], return_tensors="pt" - ) - - def call(): - return model.forward( - options, - app="Cua Driver", - task_family="closed-candidate decision", - screenshot=path, - goal=q.goal, - ) - - if first: - _, report["warmup_ms"] = measure(call) - first = False - output, elapsed = measure(call) - report["cases"].append( - { - "name": name, - "question": q.name, - "inputs": fingerprint(inputs), - "probabilities": [x.probability for x in output], - "latency_ms": elapsed, - } - ) - print(f"reference {name}/{q.name}: {elapsed:.1f} ms", flush=True) - else: - engine, report["load_ms"] = measure(lambda: MultimodalEngine(base, adapter)) - _, report["warmup_ms"] = measure(engine.warmup) - report["adapter_modules"] = engine.adapter_modules - if args.mode == "candidate": - reference = json.loads((args.output / "reference.json").read_text()) - if ( - reference["reference_source"] != report["reference_source"] - or reference["environment"] != report["environment"] - ): - raise ValueError("reference provenance or environment mismatch") - expected = {(x["name"], x["question"]): x for x in reference["cases"]} - for name, _, value in fixture_set: - request = parse_request(value) - for q in request.questions: - inputs = engine.prepare(request.image, q) - probabilities, elapsed = measure(lambda: engine.score(inputs, q)) - ref = expected[name, q.name] - difference = max( - abs(a - b) for a, b in zip(ref["probabilities"], probabilities) - ) - assert fingerprint(inputs) == ref["inputs"], ( - f"preprocessing mismatch: {name}" - ) - assert probabilities == ref["probabilities"], ( - f"probability mismatch: {name}: {difference}" - ) - report["cases"].append( - { - "name": name, - "question": q.name, - "inputs": fingerprint(inputs), - "probabilities": probabilities, - "max_abs_difference": difference, - "latency_ms": elapsed, - } - ) - print(f"candidate {name}/{q.name}: exact parity", flush=True) - else: - request = parse_request(fixture_set[1][2]) - for _ in range(5): - engine.predict(request) - report["benchmark"] = { - "case": "medium", - "batch_size": 1, - "concurrency": 1, - "warmup_requests": 5, - "runs": [], - } - for run in range(2): - torch.cuda.reset_peak_memory_stats() - latencies = [ - measure(lambda: engine.predict(request))[1] for _ in range(50) - ] - report["benchmark"]["runs"].append( - { - "run": run + 1, - "latencies_ms": latencies, - **quantiles(latencies), - "requests_per_second_serial": 1000 / statistics.mean(latencies), - "peak_allocated_bytes": torch.cuda.max_memory_allocated(), - "peak_reserved_bytes": torch.cuda.max_memory_reserved(), - } - ) - print(f"benchmark run {run + 1}: {quantiles(latencies)}", flush=True) - with torch.profiler.profile( - activities=[ - torch.profiler.ProfilerActivity.CPU, - torch.profiler.ProfilerActivity.CUDA, - ], - record_shapes=True, - ) as prof: - engine.predict(request) - torch.cuda.synchronize() - report["profile"] = [ - { - "op": x.key, - "count": x.count, - "device_time_us": x.device_time_total, - "self_device_time_us": x.self_device_time_total, - "cpu_time_us": x.cpu_time_total, - "self_cpu_time_us": x.self_cpu_time_total, - } - for x in sorted( - prof.key_averages(), key=lambda x: x.device_time_total, reverse=True - )[:30] - ] - report["peak_allocated_bytes"] = torch.cuda.max_memory_allocated() - (args.output / f"{args.mode}.json").write_text(json.dumps(report, indent=2)) - print(f"Saved {args.mode}.json", flush=True) - - -if __name__ == "__main__": - main() diff --git a/recipe/cua_s1/make_example.py b/recipe/cua_s1/make_example.py deleted file mode 100644 index 8adbc53..0000000 --- a/recipe/cua_s1/make_example.py +++ /dev/null @@ -1,71 +0,0 @@ -"""Create redistributable synthetic GUI fixtures and inline-image requests.""" - -from __future__ import annotations - -import argparse -import base64 -import json -from pathlib import Path - -from PIL import Image, ImageDraw - - -def make_example(path: Path, size=(640, 480), fmt="PNG") -> dict: - image = Image.new("RGB", size, "#f4f6f8") - draw = ImageDraw.Draw(image) - w, h = size - draw.rectangle( - (w // 10, h // 8, w * 9 // 10, h * 7 // 8), - fill="white", - outline="#8899aa", - width=2, - ) - draw.text( - (w // 7, h // 5), "Account settings", fill="black", font_size=max(12, w // 25) - ) - draw.text( - (w // 7, h // 3), - "Display name: Alice", - fill="black", - font_size=max(10, w // 32), - ) - draw.rectangle((w // 7, h // 2, w * 4 // 7, h * 2 // 3), fill="#1460b4") - draw.text( - (w // 6, h * 13 // 24), "Save changes", fill="white", font_size=max(10, w // 32) - ) - draw.text( - (w * 5 // 8, h * 13 // 24), "Cancel", fill="black", font_size=max(10, w // 32) - ) - image.save(path, format=fmt) - mime = "jpeg" if fmt == "JPEG" else "png" - return { - "model": "cua-s1-4b-0.2", - "state": { - "image": f"data:image/{mime};base64," - + base64.b64encode(path.read_bytes()).decode() - }, - "questions": { - "next": { - "type": "choice", - "instructions": "Save the changed display name.", - "criteria": { - "save": "Click Save changes", - "cancel": "Click Cancel", - "wait": "Wait", - }, - } - }, - } - - -def main(): - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--output", type=Path, default=Path("example.json")) - args = parser.parse_args() - args.output.parent.mkdir(parents=True, exist_ok=True) - value = make_example(args.output.with_suffix(".png")) - args.output.write_text(json.dumps(value, ensure_ascii=False)) - - -if __name__ == "__main__": - main() diff --git a/recipe/cua_s1/requirements-multimodal.txt b/recipe/cua_s1/requirements-multimodal.txt deleted file mode 100644 index afb7422..0000000 --- a/recipe/cua_s1/requirements-multimodal.txt +++ /dev/null @@ -1,11 +0,0 @@ -# Reference package versions from trycua/cua 0e75660, four-b uv.lock. -# Lock the CUDA wheel/driver in the experiment report for the target GPU. -torch==2.14.0 -torchvision==0.29.0 -transformers==5.17.0 -peft==0.21.0 -accelerate==1.15.0 -Pillow==11.3.0 -safetensors==0.8.0 -huggingface-hub==1.32.0 -tokenizers==0.23.2 diff --git a/src/models/cua_s1/README.md b/src/models/cua_s1/README.md index 2646837..6a07260 100644 --- a/src/models/cua_s1/README.md +++ b/src/models/cua_s1/README.md @@ -2,7 +2,7 @@ This directory owns Cua-S1 4B 0.2 ([#10](https://github.com/ThinkFlowLab/system1-omni/issues/10)): request mapping, prompt construction, adapter selection, execution, and the answer-letter readout. This page records the pinned upstream revisions, the inference contract an implementation must match, and how its outputs will be compared with the upstream reference. -Status: the `multimodal` adapter has a Transformers/PEFT CUDA worker validated on RTX 4090. See the [multimodal recipe](../../../recipe/cua_s1/README.md) for its screenshot request extension, input limits and archived GPU parity results. The `text` worker is tracked separately in [PR #13](https://github.com/ThinkFlowLab/system1-omni/pull/13); the text mapping below remains its contract. +Status: planned; nothing is implemented or validated yet. The first target is the `text` adapter on CUDA, starting with a worker that loads the model directly through Hugging Face Transformers and PEFT. The `multimodal` adapter is deferred; see [Not covered yet](#not-covered-yet). ## Pinned revisions @@ -105,7 +105,7 @@ The bfloat16 worker's own difference from the fp32 worker is reported next to ea ## Not covered yet -- Text-adapter serving in this checkout (tracked in PR #13), and native GPU kernels. +- The `multimodal` adapter: image preprocessing, the vision tower and the vision LoRA. This is tracked in [#10](https://github.com/ThinkFlowLab/system1-omni/issues/10). - `score` and `noul` questions. - More than 26 options per question. - The Metal backend. diff --git a/tests/cua_s1/test_download_weights.py b/tests/cua_s1/test_download_weights.py deleted file mode 100644 index 5fb9939..0000000 --- a/tests/cua_s1/test_download_weights.py +++ /dev/null @@ -1,83 +0,0 @@ -"""Download setup uses the upstream manifest without checking a copy into source.""" - -import importlib.util -import io -import json -import sys -from pathlib import Path -from types import SimpleNamespace - -import pytest - - -@pytest.mark.parametrize("corrupt", [False, True]) -def test_manifest_is_verified_before_downloading_weights( - tmp_path, monkeypatch, corrupt -): - from models.cua_s1.multimodal import model - - raw = json.dumps( - { - "artifacts": [ - { - "repo_id": "test/base", - "revision": "fixed", - "name": "Qwen3.5-4B", - "files": {"config.json": {}}, - } - ] - } - ).encode() - import hashlib - - monkeypatch.setattr( - model, "WEIGHTS_MANIFEST_SHA256", hashlib.sha256(raw).hexdigest() - ) - downloads = [] - - def download(**kwargs): - downloads.append(kwargs) - kwargs["local_dir"].mkdir(parents=True) - - monkeypatch.setitem( - sys.modules, "huggingface_hub", SimpleNamespace(snapshot_download=download) - ) - path = Path(__file__).resolve().parents[2] / "recipe/cua_s1/download_weights.py" - spec = importlib.util.spec_from_file_location("download_weights_test", path) - module = importlib.util.module_from_spec(spec) - spec.loader.exec_module(module) - payload = raw + b" " if corrupt else raw - urls = [] - - def fetch(url, timeout): - urls.append(url) - assert timeout == 30 - return io.BytesIO(payload) - - monkeypatch.setattr(module, "urlopen", fetch) - verified = [] - - def verify(base, adapter): - assert (base.parent / "weights.lock.json").read_bytes() == raw - verified.append((base, adapter)) - - monkeypatch.setattr(module, "verify_weights", verify) - dest = tmp_path / "weights" - monkeypatch.setattr(sys, "argv", [str(path), "--dest", str(dest)]) - if corrupt: - with pytest.raises(ValueError, match="manifest checksum"): - module.main() - assert not downloads and not verified and not dest.exists() - else: - module.main() - assert downloads == [ - { - "repo_id": "test/base", - "revision": "fixed", - "local_dir": dest / "Qwen3.5-4B", - "allow_patterns": ["config.json"], - "token": False, - } - ] - assert verified == [(dest / "Qwen3.5-4B", dest / "cua-s1-4b-0.2/multimodal")] - assert model.REFERENCE_REVISION in urls[0] diff --git a/tests/cua_s1/test_evaluation.py b/tests/cua_s1/test_evaluation.py deleted file mode 100644 index cca8a45..0000000 --- a/tests/cua_s1/test_evaluation.py +++ /dev/null @@ -1,65 +0,0 @@ -"""Provenance checks must fail before a changed oracle can certify parity.""" - -import importlib.util -from pathlib import Path - -import pytest - - -def test_modified_reference_is_rejected(tmp_path, monkeypatch): - recipe = Path(__file__).resolve().parents[2] / "recipe/cua_s1" - monkeypatch.syspath_prepend(str(recipe)) - spec = importlib.util.spec_from_file_location( - "evaluation", recipe / "evaluate_multimodal.py" - ) - module = importlib.util.module_from_spec(spec) - spec.loader.exec_module(module) - source = tmp_path / module.REFERENCE_SOURCE - source.parent.mkdir(parents=True) - source.write_text("modified oracle") - with pytest.raises(ValueError, match="reference source differs"): - module.verify_reference(tmp_path) - - -def test_environment_survives_json_roundtrip(monkeypatch): - import json - import sys - from types import SimpleNamespace - - recipe = Path(__file__).resolve().parents[2] / "recipe/cua_s1" - monkeypatch.syspath_prepend(str(recipe)) - spec = importlib.util.spec_from_file_location( - "evaluation", recipe / "evaluate_multimodal.py" - ) - module = importlib.util.module_from_spec(spec) - spec.loader.exec_module(module) - torch = SimpleNamespace( - cuda=SimpleNamespace( - get_device_name=lambda: "GPU", get_device_capability=lambda: (8, 9) - ), - version=SimpleNamespace(cuda="13.0"), - get_num_threads=lambda: 16, - get_num_interop_threads=lambda: 16, - ) - monkeypatch.setitem(sys.modules, "torch", torch) - monkeypatch.setattr(module.importlib.metadata, "version", lambda name: "pinned") - monkeypatch.setattr(module.subprocess, "check_output", lambda *a, **kw: "driver\n") - environment = module.environment() - assert json.loads(json.dumps(environment)) == environment - - -def test_generated_fixtures_satisfy_required_instructions(tmp_path, monkeypatch): - from models.cua_s1.multimodal.protocol import parse_request - - recipe = Path(__file__).resolve().parents[2] / "recipe/cua_s1" - monkeypatch.syspath_prepend(str(recipe)) - spec = importlib.util.spec_from_file_location( - "evaluation", recipe / "evaluate_multimodal.py" - ) - module = importlib.util.module_from_spec(spec) - spec.loader.exec_module(module) - fixtures = module.cases(tmp_path) - requests = [parse_request(value) for _, _, value in fixtures] - assert len(requests) == 8 - assert sum(len(value.questions) for value in requests) == 9 - assert requests[-1].questions[1].goal == "" diff --git a/tests/cua_s1/test_model.py b/tests/cua_s1/test_model.py deleted file mode 100644 index d37728f..0000000 --- a/tests/cua_s1/test_model.py +++ /dev/null @@ -1,124 +0,0 @@ -import pytest - -from models.cua_s1.multimodal.model import letter_ids, validate_adapter_config - - -class Tokenizer: - def encode(self, text, add_special_tokens): - assert add_special_tokens is False - return [ord(text) - 33] - - -def test_letter_readout_is_in_candidate_order(): - assert letter_ids(Tokenizer(), 3) == [32, 33, 34] - - -def test_multitoken_letters_are_rejected(): - class Bad: - def encode(self, *args, **kwargs): - return [1, 2] - - with pytest.raises(ValueError, match="single token"): - letter_ids(Bad(), 2) - - -def test_text_adapter_is_rejected_before_model_load(): - with pytest.raises(ValueError, match="multimodal"): - validate_adapter_config( - { - "peft_type": "LORA", - "r": 16, - "lora_alpha": 32, - "target_modules": ["q_proj", "k_proj"], - } - ) - - -def test_multimodal_adapter_contract(): - validate_adapter_config( - { - "peft_type": "LORA", - "r": 16, - "lora_alpha": 32, - "base_model_name_or_path": "Qwen/Qwen3.5-4B", - "target_modules": [ - "q_proj", - "k_proj", - "v_proj", - "o_proj", - "gate_proj", - "up_proj", - "down_proj", - "linear_fc1", - "linear_fc2", - ], - } - ) - - -def test_unlisted_model_files_cannot_override_verified_shards(tmp_path, monkeypatch): - import hashlib - import json - - from models.cua_s1.multimodal import model - - base, adapter = tmp_path / "base", tmp_path / "adapter" - base.mkdir() - adapter.mkdir() - (base / "config.json").write_bytes(b"{}") - manifest = tmp_path / "weights.lock.json" - manifest.write_text( - json.dumps( - { - "artifacts": [ - { - "role": "base", - "files": { - "config.json": { - "size": 2, - "sha256": hashlib.sha256(b"{}").hexdigest(), - } - }, - } - ] - } - ) - ) - monkeypatch.setattr( - model, - "WEIGHTS_MANIFEST_SHA256", - hashlib.sha256(manifest.read_bytes()).hexdigest(), - ) - model.verify_weights(base, adapter) - (base / "model.safetensors").write_bytes(b"override") - with pytest.raises(ValueError, match="unlisted"): - model.verify_weights(base, adapter) - - -def test_all_question_lengths_are_checked_before_inference(): - from models.cua_s1.multimodal.model import MultimodalEngine - from models.cua_s1.multimodal.protocol import InvalidRequest, Question, Request - - engine = object.__new__(MultimodalEngine) - first = Question("first", ("a",), ("A",), "") - second = Question("second", ("b",), ("B",), "") - forwarded = [] - - def prepare(image, question): - if question.name == "second": - raise InvalidRequest("processed prompt exceeds 4096 tokens") - return {} - - engine.prepare = prepare - engine.score = lambda inputs, q: forwarded.append(q) - with pytest.raises(InvalidRequest, match="4096"): - engine.predict(Request(None, (first, second))) - assert forwarded == [] - - -def test_weights_manifest_must_match_pinned_upstream_digest(tmp_path): - from models.cua_s1.multimodal.model import verify_weights - - (tmp_path / "weights.lock.json").write_text('{"artifacts": []}') - with pytest.raises(ValueError, match="manifest checksum"): - verify_weights(tmp_path / "base", tmp_path / "adapter") diff --git a/tests/cua_s1/test_protocol.py b/tests/cua_s1/test_protocol.py deleted file mode 100644 index 00ecd76..0000000 --- a/tests/cua_s1/test_protocol.py +++ /dev/null @@ -1,172 +0,0 @@ -import base64 -import io -import json - -import pytest -from PIL import Image - -from models.cua_s1.multimodal.protocol import ( - InvalidRequest, - answer, - build_messages, - decode_request, - parse_request, -) - - -def image_url(fmt="PNG", size=(32, 32)): - out = io.BytesIO() - Image.new("RGB", size, "white").save(out, format=fmt) - mime = "jpeg" if fmt == "JPEG" else "png" - return f"data:image/{mime};base64," + base64.b64encode(out.getvalue()).decode() - - -def request(): - return { - "model": "cua-s1-4b-0.2", - "state": {"image": image_url()}, - "questions": { - "next": { - "type": "choice", - "instructions": "Submit the form", - "criteria": {"submit": "Submit", "cancel": "Cancel"}, - } - }, - } - - -def test_image_and_order_are_preserved(): - r = parse_request(request()) - assert r.image.mode == "RGB" and r.image.size == (32, 32) - assert r.questions[0].keys == ("submit", "cancel") - assert r.questions[0].labels == ("Submit", "Cancel") - - -def test_prompt_keeps_image_block_and_upstream_text(): - q = parse_request(request()).questions[0] - msg = build_messages(q) - assert msg[1]["content"][0]["type"] == "image" - assert msg[1]["content"][1]["text"] == ( - "Goal: Submit the form\n\nApp: Cua Driver\nTask family: closed-candidate decision\n\n" - "The current screenshot is attached.\n\nOptions:\n" - 'A. Decision "Submit" -> select\nB. Decision "Cancel" -> select\n\n' - "Answer with a single letter." - ) - - -def test_structured_values_and_escaping(): - r = request() - r["questions"]["next"]["instructions"] = {"目标": "提交"} - r["questions"]["next"]["criteria"] = {"fallback": None, "obj": {"x": '"\n'}} - q = parse_request(r).questions[0] - assert q.goal == '{"目标": "提交"}' - assert q.labels == ( - "fallback", - json.dumps(json.dumps({"x": '"\n'}, ensure_ascii=False), ensure_ascii=False)[ - 1:-1 - ], - ) - - -@pytest.mark.parametrize( - "state", - [ - {}, - {"image": "/etc/passwd"}, - {"image": "https://example.com/a.png"}, - {"image": "data:image/png;base64,!!"}, - {"image": image_url(), "text": "ignored"}, - ], -) -def test_invalid_images_and_unknown_state_fields(state): - r = request() - r["state"] = state - with pytest.raises(InvalidRequest): - parse_request(r) - - -def test_mime_mismatch_and_oversized_dimensions(): - for url in [ - image_url().replace("image/png", "image/jpeg"), - image_url(size=(2049, 1)), - ]: - r = request() - r["state"]["image"] = url - with pytest.raises(InvalidRequest): - parse_request(r) - - -@pytest.mark.parametrize( - "criteria", [{}, {str(i): "x" for i in range(27)}, {"a": 1}, {"a": True}] -) -def test_invalid_candidates(criteria): - r = request() - r["questions"]["next"]["criteria"] = criteria - with pytest.raises(InvalidRequest): - parse_request(r) - - -@pytest.mark.parametrize("kind", ["score", "noul"]) -def test_unsupported_question_rejects_entire_request(kind): - r = request() - r["questions"]["bad"] = {"type": kind, "instructions": "x"} - with pytest.raises(InvalidRequest): - parse_request(r) - - -def test_duplicate_keys_and_nonfinite_json(): - for raw in [ - b'{"model":1,"model":2}', - b'{"x":NaN}', - b'{"x":Infinity}', - b"[]", - b"not json", - ]: - with pytest.raises(InvalidRequest): - decode_request(raw) - - -def test_entropy_confidence_and_earliest_tie(): - q = parse_request(request()).questions[0] - result = answer(q, [0.5, 0.5]) - assert result["choice"] == "submit" - assert result["confidence"] == 0.0 - assert result["probabilities"] == {"submit": 0.5, "cancel": 0.5} - r = request() - r["questions"]["next"]["criteria"] = {"only": "Only"} - assert answer(parse_request(r).questions[0], [1.0])["confidence"] == 1.0 - - -def test_jpeg_supported(): - r = request() - r["state"]["image"] = image_url("JPEG") - assert parse_request(r).image.mode == "RGB" - - -@pytest.mark.parametrize( - "token", ["<|image_pad|>", "<|video_pad|>", "<|vision_start|>", "<|vision_end|>"] -) -@pytest.mark.parametrize("field", ["instructions", "criteria"]) -def test_media_control_tokens_are_rejected(token, field): - value = request() - value["questions"]["next"][field] = ( - token if field == "instructions" else {"a": {"text": token}} - ) - with pytest.raises(InvalidRequest, match="control token"): - parse_request(value) - - -@pytest.mark.parametrize("instructions", ["", None]) -def test_explicit_empty_or_null_instructions_omits_goal(instructions): - value = request() - value["questions"]["next"]["instructions"] = instructions - question = parse_request(value).questions[0] - assert question.goal == "" - assert "Goal:" not in build_messages(question)[1]["content"][1]["text"] - - -@pytest.mark.parametrize("size", [(200, 1), (1, 200), (199, 1), (1, 199)]) -def test_supported_aspect_ratio_boundary(size): - value = request() - value["state"]["image"] = image_url(size=size) - assert parse_request(value).image.size == size diff --git a/tests/cua_s1/test_server.py b/tests/cua_s1/test_server.py deleted file mode 100644 index 50bd2cb..0000000 --- a/tests/cua_s1/test_server.py +++ /dev/null @@ -1,204 +0,0 @@ -import json -import threading -import urllib.error -import urllib.request - -import pytest -from test_protocol import image_url, request - -from frontend.cua_s1 import Handler, WorkerServer -from models.cua_s1.multimodal.protocol import MAX_BODY - - -class Engine: - def predict(self, parsed): - return { - "model": "test:multimodal", - "answers": {q.name: {"type": "choice"} for q in parsed.questions}, - } - - -@pytest.fixture -def worker(): - server = WorkerServer(("127.0.0.1", 0), Engine()) - thread = threading.Thread(target=server.serve_forever, daemon=True) - thread.start() - yield server, f"http://127.0.0.1:{server.server_port}" - server.shutdown() - server.server_close() - thread.join() - - -@pytest.fixture -def deferred_cleanup(worker, monkeypatch): - """Hold cleanup until the test starts waiting for the inference lock.""" - server, _ = worker - lock = server.inference_lock - allow_cleanup = threading.Event() - - class DeferredLock: - def acquire(self, blocking=True, timeout=-1): - if blocking: - allow_cleanup.set() - return lock.acquire(blocking, timeout) - - def release(self): - lock.release() - - def locked(self): - return lock.locked() - - server.inference_lock = DeferredLock() - send_json = Handler.send_json - - def send_then_wait(handler, status, value): - send_json(handler, status, value) - # The client has the complete response, but finally has not run yet. - if not allow_cleanup.wait(timeout=5): - raise AssertionError("test did not wait for handler cleanup") - - monkeypatch.setattr(Handler, "send_json", send_then_wait) - try: - yield worker - finally: - allow_cleanup.set() - - -def call(url, body=None, **headers): - data = ( - body if isinstance(body, bytes) or body is None else json.dumps(body).encode() - ) - req = urllib.request.Request( - url, data=data, headers={"Content-Type": "application/json", **headers} - ) - try: - with urllib.request.urlopen(req, timeout=5) as response: - return response.status, json.load(response) - except urllib.error.HTTPError as response: - return response.code, json.load(response) - - -def test_health_and_prediction(worker): - _, url = worker - assert call(url + "/health")[0] == 200 - status, body = call(url + "/v1/systemone", request()) - assert status == 200 and "next" in body["answers"] - - -def test_invalid_question_never_reaches_model(worker): - _, url = worker - r = request() - r["questions"]["next"]["type"] = "noul" - status, body = call(url + "/v1/systemone", r) - assert status == 422 and set(body) == {"detail"} - - -def test_busy_worker_rejects_instead_of_queueing_gpu_work(worker): - server, url = worker - server.inference_lock.acquire() - try: - assert call(url + "/health")[0] == 200 - assert call(url + "/v1/systemone", request())[0] == 503 - finally: - server.inference_lock.release() - - -def test_body_limit_checked_before_reading(worker): - _, url = worker - assert ( - call(url + "/v1/systemone", {}, **{"Content-Length": str(MAX_BODY + 1)})[0] - == 413 - ) - - -def test_model_failure_is_not_reported_as_success(deferred_cleanup): - server, url = deferred_cleanup - - def fail(_): - raise RuntimeError("private file or input must not leak") - - server.engine.predict = fail - status, body = call(url + "/v1/systemone", request()) - assert status == 500 and body == {"detail": "inference failed"} - assert server.inference_lock.acquire(timeout=2), "handler did not release the lock" - server.inference_lock.release() - - -@pytest.mark.parametrize( - "raw", - [ - b"not json", - b'{"x":1,"x":2}', - b'{"x":{"y":1,"y":2}}', - b'{"x":NaN}', - b'{"x":Infinity}', - b'{"x":1e400}', - b"[]", - b"null", - b'{"x":"\xff"}', - b'{"x":"\\ud800"}', - b'{"\\ud800":1}', - b"[" * 2000 + b"]" * 2000, - "{}".encode("utf-16"), - ], -) -def test_malformed_json_returns_400_without_inference(deferred_cleanup, raw): - server, url = deferred_cleanup - - def unexpected(_): - raise AssertionError("malformed JSON reached inference") - - server.engine.predict = unexpected - status, body = call(url + "/v1/systemone", raw) - assert status == 400 and set(body) == {"detail"} - assert server.inference_lock.acquire(timeout=2), "handler did not release the lock" - server.inference_lock.release() - - -def test_missing_instructions_rejects_whole_request(worker): - server, url = worker - value = request() - value["questions"]["second"] = {"type": "choice", "criteria": {"a": "A"}} - - def unexpected(_): - raise AssertionError("invalid question reached inference") - - server.engine.predict = unexpected - status, body = call(url + "/v1/systemone", value) - assert status == 422 and set(body) == {"detail"} - assert "instructions" in body["detail"] - - -@pytest.mark.parametrize( - "route,body,headers,status", - [ - ("/missing", None, {}, 404), - ("/missing", {}, {}, 404), - ("/v1/systemone", {}, {"Content-Type": "text/plain"}, 415), - ("/v1/systemone", {}, {"Transfer-Encoding": "chunked"}, 411), - ("/v1/systemone", {}, {"Content-Length": "invalid"}, 400), - ("/v1/systemone", {}, {"Content-Length": str(MAX_BODY + 1)}, 413), - ], -) -def test_transport_errors_use_detail(worker, route, body, headers, status): - _, url = worker - actual, response = call(url + route, body, **headers) - assert actual == status and set(response) == {"detail"} - - -@pytest.mark.parametrize("size", [(2048, 1), (1, 2048), (201, 1), (1, 201)]) -def test_unsupported_image_aspect_ratio_returns_422_before_inference(worker, size): - server, url = worker - reached_engine = [] - - def unexpected(parsed): - reached_engine.append(parsed) - raise ValueError("unsupported processor input") - - server.engine.predict = unexpected - value = request() - value["state"]["image"] = image_url(size=size) - status, body = call(url + "/v1/systemone", value) - assert status == 422 and set(body) == {"detail"} - assert "aspect ratio" in body["detail"] - assert not reached_engine